Activiteiten van
maximaal 10 minuten

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

Doelen :

• Het gebruik van de TI-Python applicatie
• Wiskundige bewerkingen uitvoeren in Python
• Het gebruik van de Python Shell

Druk op de prgm-toets

Kies Python App

Opmerking: Je kunt de Python applicatie ook starten door op de apps toets te drukken en dan « Python » te kiezen.

Je ziet nu een scherm waarin al eventueel opgeslagen programma’s kunnen staan.

De menuopties in de onderste regel corresponderen met de functietoetsen F1 t/m F5.

Python programma’s worden meestal gemaakt in een editor en uitgevoerd in de zogenaamde shell.

In deze shell kun je ook rechtstreeks Python opdrachten intypen en uitvoeren.

We beginnen met de shell (F4)

In de onderste regel is te zien dat de functietoetsen een andere betekenis hebben gekregen.

Python kent een aantal basisbewerkingen zoals +, -, * en /.

Voor machtsverheffen gebruik je in Python twee keer-tekens.

Voor veel wiskundige bewerkingen (bijvoorbeeld worteltrekken) heb je een module nog. Zo’n module moet je dan eerst apart laden.

Met de knop [ math ] krijg je een lijst met modules en de daarbij behorende functies.

Om een functie uit de module te kunnen gebruiken moet je eerst optie 1 kiezen.

Alle functies uit de module komen dan beschikbaar.

De wortel van 3 schrijf je in Python als sqrt(3).

In Python kun je ook variabelen gebruiken en er vervolgens mee rekenen.

De naam van een variabele moet altijd beginnen met een letter en mag alleen alfanumerieke tekens, cijfers of een onderstrepingsteken ( _ ) bevatten.

Als bijvoorbeeld a=3 en b1=5, dan kun je deze twee optellen.

Variabele namen zijn hoofdlettergevoelig. (a is een andere variabele dan A)

Het ‘=’ teken krijg je als je de [ sto → ] toets indrukt.

Samenvatting

De formule van de afgelegde weg bij een vrije val zonder luchtweerstand is s=1/2gt².

De variabele g is hierbij de gravitatieversnelling (g=9.81)

Bereken nu de afgelegde weg na 1.5 seconden.

Je kunt de Python app afsluiten door F5 (Files) te kiezen en daarna nog een keer F5 (Manage). In het nu gegeven menu kun je voor Quit Python kiezen.

In deze tweede les maak je kennis met de Python editor en beginnen we met programmeren

Doelen :

• Het gebruik van de TI-Python editor
• Het definiëren van een functie

In de Python shell kun je eigenlijk maar een opdracht tegelijk uitvoeren.

Een computerprogramma bestaat meestal uit een serie opdrachten.

Daarom heeft Python ook een editor. Hierin kun je een reeks van opdrachten intypen die dan als een geheel kunnen worden uitgevoerd in de shell.

Open de Python app en kies nu voor F3 (New).

Je krijgt eerst de vraag om je programma een naam te geven. In het voorbeeld hiernaast is de naam TEST gekozen.

Druk daarna op F5 (Ok)

We gaan een Python programma maken dat de tekst “Hallo wereld” afdrukt.

Merk op dat de tekst in het groen op het scherm verschijnt. Dat is een hulpmiddel om snel te kunnen zien wanneer de aanhalingstekens moeten eindigen.

Tekst staat altijd tussen aanhalingstekens.

De eerste opdracht is print().

Deze opdracht staat in I/O-menu. (Kies F1(Fns...) en dan I/O)

Voer het programma uit met F4 (Run)

In de shell wordt nu de tekst “Hallo wereld” afgedrukt.

De opdracht print() zorgt er dus voor dat er iets wordt afgedrukt.

We maken een nieuw programma waarin we de functie f(x)=2x+3 definiëren.

Kies F5(Files) en dan New. Geef je programma weer een naam (bijvoorbeeld FUNCTIE) en open de editor.

Een functie in Python heeft een vast format.

Dat format kun je krijgen door F1(Fns...) te kiezen. Er staan twee keuzes. Kies de eerste.

Typ nu een naam (bijvoorbeeld f) en dan tussen de haakjes het argument (bijvoorbeeld x).

In Python moet deze regel met een dubbele punt eindigen.

Druk op [ ↓ ] om met de cursor naar de volgende regel te gaan en typ dan de formule in. Als je aan het eind van de regel op [enter] drukt verschijnen er weer twee stippen.

Dit zijn twee spaties die aangeven dat je binnen het functieblok typt.

Alle regels met dezelfde inspringing (indent) horen bij hetzelfde functieblok.

De laatste regel geeft aan wat de uitkomst van de functie is.

(Deze opdracht kun je in het functie menu vinden).

Voer het programma uit met Run.

Er verschijnt een melding dat het programma in de shell is geladen.

Als je f(5) wilt berekenen kun je dat intypen, maar de functie kun je nu ook vinden met de vars toets

Druk vars en dan op [enter] en vul de waarde 5 in.

Met de pijl omhoog kun je de vorige invoer terugkrijgen en de ingevulde waarde door een andere vervangen.

Een functieblok kan meerdere regels bevatten.

Hiernaast zie je hoe je de functie f(x)=(2x+3)/(x-1) kunt opsplitsen in stukjes.

Vaak bestaan functies uit meerdere regels.

Je kunt de Python app afsluiten door F5 (Files) te kiezen en daarna nog een keer F5 (Manage). In het nu gegeven menu kun je voor Quit Python kiezen.

In deze les leer je hoe je gegevens in een programma kan invoeren en maak je kennis met verschillende datatypes die in Python gebruikt worden.

Doelen :

• Invoeren van gegevens in een programma
• Werken met verschillende gegevens types

Vaak wil je de loop van een computerprogramma kunnen beïnvloeden tijdens de uitvoering ervan.

Een van de opdrachten waarmee dat kan is input().

Deze opdracht staat in I/O-menu. (Kies F1(Fns...) en dan I/O)

Als je deze opdracht gebruikt wacht het programma tot dat je een tekst hebt ingetypt en met de enter-toets hebt afgesloten.

Open de Python app en kies weer voor F3 (New)

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

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 a.

Het programma kan dan beginnen zoals hiernaast.

Het vraagteken kun je vinden bij F2(a A #)

In dit voorbeeld is een eigenschap van Python te zien: Je kunt twee teksten samenvoegen tot één met een plus-teken.

Het programma kan nog ietsje korter. De eerste twee regels kun je samenvoegen door de tekst die op het scherm moet worden afgedrukt op te nemen in de input-opdracht.

In Python zijn er verschillende soorten data (gegevenstypes).

Een ervan is tekst. Dat heet in Python: string.

De input-opdracht geeft altijd een stringtype.

Als je een programma schrijft waarin je bijvoorbeeld een getal wilt invoeren, dan heb je een extra opdracht nodig.

Maar eerst iets over datatypes.

Ga naar de Python shell met F5(Files) en dan F4(Shell).

Maak zo nodig het scherm schoon met F3(Tools)

Met F1(Fns...) kun je naar het tabblad Type en daar kiezen voor de functie type().

Deze functie geeft het type van de ingevoerde data.

Zo kun je hiernaast zien dat de tekst van het type str is (str staat voor string).

Het getal 23 is van het type int (van integer wat geheel getal betekent).

En 3.14 is van het type float. (Dit staat voor kommagetal)

Je kunt datatypes ook veranderen.

Zo kun je van een integer (int) een float maken.

Maar bijvoorbeeld ook van het stringtype een integer (als de tekst alleen uit cijfers bestaat)

Zie hiernaast.

We gaan dit gebruiken in een programma.

Begin met een nieuw programma.

Het programma moet eerst vragen om een geheel getal en dan het kwadraat ervan afdrukken.

Het programma hiernaast werkt alleen als je gehele getallen intypt.

Als je een kommagetal intypt krijg je een foutmelding.

Om het kwadraat van een kommagetal te berekenen moet het programma gewijzigd worden.

Pas het programma aan zodat ook het kwadraat van een kommagetal kan worden berekend door int() te vervangen door float().

Hiernaast staat een voorbeeld

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.

In elke programmeertaal is er wel een voorwaardelijke opdracht.

Zo’n opdracht heeft de vorm: als ... dan ... .

Als een bepaalde voorwaarde geldt dan moet er iets gebeuren.

Vaak kan er nog een extra regel aan toegevoegd worden wat er anders moet gebeuren.

Voorbeeld:

Een autoverhuurbedrijf heeft de volgende aanbieding:

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

We maken in de Python editor een functie die de prijs berekent voor het aantal gereden kilometers.

Open een new Python programma en geef het een naam.

Kies nu F1(Fns...) en Func voor het functiesjabloon.

Noem de functie bijvoorbeeld bedrag(k)

Zet de cursor in de tweede regel achter de twee stippen.

Kies nu F1(Fns...) en Ctl

Je ziet hier een menu met allerlei sjablonen voor programmastructuren.

We kiezen 2:if .. else ..

Je krijgt op het scherm de juiste structuur te zien met de nodige inspringingen.

In Python geldt de regel dat alle opdrachten met dezelfde inspringing

bij elkaar horen. Dit hoort bij de syntax van de taal.

Het geeft tegelijkertijd een overzichtelijk beeld van de structuur van het programma.

Let weer op de dubbele punt aan het eind van de regel met if en ook die met else.

Ook dat is een syntaxeigenschap van Python

(Als je die weglaat krijg je een foutmelding.)

Je ziet hiernaast hoe de functie er bijvoorbeeld uit kan zien.

Als k<=70 dan is de uitkomst 66.

In het andere geval berekent de functie eerst het aantal kilometers boven de 70 en daarna de kosten.

In dit voorbeeld zie je dat een blok (onder else in dit geval) uit meerdere regels kan bestaan.

Het <= teken kun je vinden met F1(Fns...) en dan Ops.

Maar het kan ook met [ 2nd] [ math ]

Voer het programma uit met Run.

Met de vars toets kun je de functie opvragen en er een waarde invullen.

Om een nieuwe waarde in te vullen kun je weer op de vars toets drukken.

Je kan ook met de pijl omhoog de vorige regel weer opnieuw in beeld krijgen en dan de waarde wijzigen.

In deze les leren we hoe je opdrachten makkelijk kunt herhalen

Doelen :

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

De kracht van een computerprogramma is de mogelijkheid om een serie opdrachten eventueel met een kleine wijziging te herhalen.

Een van de opdrachten hiervoor is de for ... lus

We maken een programma dat van een rij getallen het kwadraat en de derde macht afdrukt.

Open een nieuw Python programma en geef het een naam.

Kies F1(Fns...) en dan Ctl en kies nu optie 4.

Tussen de haakjes bij range() komt het aantal herhalingen te staan.

De lus werkt als volgt:

De variabele i krijgt eerst de waarde 0.

Als de lus eenmaal is doorlopen wordt i met 1 verhoogd (dus dan is i=1)

De volgende keer wordt i opnieuw met 1 verhoogd en dan is i=2.

Dit wordt zo vaak herhaald als aangeven bij range.

Stel we willen van de eerste vijf gehele getallen het kwadraat en de derde macht afdrukken, dan is het aantal herhalingen dus 5.

Het programma kan er nu uitzien zoals hiernaast.

Je ziet weer duidelijk de structuur.

Alles wat even ver is ingesprongen wordt 5 keer herhaald.

Merk op dat i loopt van 0 t/m 4.

Verander het programma zo dat i de waarden 10 t/m 18 aanneemt.

Tussen de haakjes van range() kun je een beginwaarde en een eindwaarde intypen. Dus: range( .. , .. )

Merk op dat de eindwaarde 19 is.

In range(a, b) neemt i de waarden a t/m b-1 aan.

We gaan het programma wijzigen zodat de uitkomsten in een lijst worden opgeslagen.

Een lijst is een rij gegevens. In Python noteer je een lijst met vierkante haken.

Bijvoorbeeld: [3,5,7,9] is een lijst met vier getallen.

Een lijst kan ook leeg zijn (notatie: [ ]).

Begin met een lege lijst. In het voorbeeld noemen we deze: lst

Voeg nu 8 keer een nieuwe waarde toe aan de bestaande lijst.

Append() kun je vinden in het Lijst-menu (F1(Fns...), List, append.)

Append is een Pythonmethode om een lijst uit te breiden met nieuwe elementen.

Voer het programma uit met Run.

Je ziet nu een lijst met de eerste acht kwadraten.

De variabele nu een lijst.

Dat kun je ook zien door in de shell op de var-toets te drukken. Dan zie je lst in het

scherm en als je die kiest en op enter drukt krijg je opnieuw de lijst in beeld.

In deze les leren we een andere herhalingsopdracht.

Doelen :

• Hoe gebruik je de opdracht while ... .
• Wat is de syntax voor de 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... opdracht gebruiken.

Dit kun je lezen als:

Zolang een bepaalde voorwaarde geldt blijf dan herhalen

We maken een programma voor het volgende probleem:

Gooi met een dobbelsteen en herhaal dit net zolang totdat er 6 is gegooid.

Je weet dus van tevoren niet hoe vaak je moet gooien.

Open een nieuw Python programma en geef het een naam.

Omdat we randomgetallen gaan gebruiken hebben we de module nodig waarin die opdrachten staan.

Die moeten we als eerste invoegen.

Kies F1(Fns...) Modul 2:random. (Dit kan ook met: [ math ]» en dan 2:random)

We gaan in het programma twee variabelen gebruiken.

De variabele t die bijhoudt hoe vaak er is gegooid en de variabele d die bijhoudt wat er is gegooid. Beide variabelen geven we als beginwaarde 0.

Voeg het sjabloon voor while ... in met F1(Fns...) en dan Ctl optie 8.

Achter while komt de voorwaarde te staan.

Dat is in dit geval: d is niet gelijk aan 6

In Python noteer je dat als: d!=6. (je kunt dit vinden met [ 2nd ] [ math ])

In het herhalingsblok komen twee opdrachten te staan. De eerste is het kiezen van een randomgetal tussen 1 en 6 en de tweede is de teller (t) 1 verhogen. Als de uitslag gelijk is aan 6 wordt de lus verlaten en volgt nog de opdracht om het aantal worpen af te drukken.

Als je het programma een aantal keren uitvoert (Run) dan zie je waarschijnlijk verschillende waarden voor t.

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 zodat het werpen met de dobbelsteen totdat zes is gegooid in een functie wordt gezet (noem die functie bijvoorbeeld dobbelen()).

Als je de functie aanroept geeft die als uitkomst het aantal worpen.

Als we deze functie 100 keer aanroepen en we tellen die uitkomsten bij elkaar op waarna we die som delen door 100, dan krijgen we het gemiddelde. We voegen nu een for-lus toe die dit 100 keer doet. Maar eerst maken we een nieuwe variabele voor de som en starten met de waarde 0.

In het programma hiernaast zie je dat de for-lus 100 keer doorlopen wordt en dat elke keer de som wordt opgehoogd met het nieuwe aantal worpen. Uiteindelijk wordt de som gedeeld door 100 voor het berekenen van het gemiddelde.

Voer het programma uit met Run.

Om het gemiddelde nauwkeuriger te bepalen kun je bijvoorbeeld het getal 100 in het programma wijzigen in 1000 (op twee plekken). Je berekent dan het gemiddelde van 1000 experimenten.

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

Doelen :

• Hoe gebruik je de opdracht if ... else ... .
• De math module gebruiken.

De vergelijking ax² + bx + c = 0 heeft twee, een of nul oplossingen. We gaan een functie schrijven met als argumenten de getallen a, b en c. De uitkomsten zijn de oplossingen of de mededeling dat er geen oplossing is.

Begin een nieuw programma en kies bij het scherm waar de naam moet worden ingetypt met F3(Types) voor Math Calculations. We hebben deze module nodig omdat we de wortel van een getal willen berekenen. Als het goed is krijg je hetzelfde scherm als hiernaast.

De eerste regel begint met een #. In Python betekent dit dat het een commentaarregel is en niet wordt uitgevoerd. Je kunt de math-module ook handmatig invoegen.

We beginnen met het sjabloon van een functie en noemen deze functie losop(a,b,c).

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

We beginnen met het berekenen van de discriminant D

Er zijn drie mogelijkheden:

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

We gebruiken daarvoor het if ... elif ... else ... sjabloon.

Eerst het geval D<0. Dan zijn er dus geen oplossingen.

(Het < teken vind je bij [ 2nd ] [ math ])

Het volgende geval is als D=0.

Dan is er één oplossing.

(Let op: in Python gebruik je een dubbel = teken om de gelijkheid te controleren).

Het laatste geval is als D>0. Dat is het enige geval dat overblijft.

Er zijn dan twee oplossingen.

Voer het programma uit met Run.

In de shell kun je dan met de var-toets de functie opvragen en er getallen invullen.

Let op dat de ingevulde getallen door komma’s worden gescheiden.

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.

Met behulp van deze functie berekenen we daarna het honderdste priemgetal.

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)

Dit betekent: als a%b = 0 dan is b een deler van a. (b past een heel aantal keren in a want de rest is nul).

Begin met de definitie van de functie ispriem(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.

True en False kun je vinden met F2(a A #).

Om het honderdste priemgetal te vinden maken we een while-lus.

Eerst kiezen we een teller (i) en geven die de waarde 0.

De variabele p doorloopt de getallen 2 en verder.

Telkens als p een priemgetal is wordt i een opgehoogd tot dat i=100.

Ga na dat je op deze manier het honderdste priemgetal krijgt.

De functie is_priem(n) in het programma is erg traag.

Als je bijvoorbeeld het 200-ste priemgetal wilt berekenen kost dat veel tijd.

Je kunt de functie aanmerkelijk sneller maken.

Als 3 een deler is van 27, dan is 9 dat ook want 3*9=27.

Telkens als je een deler hebt gevonden heb je er automatisch nog een.

Eigenlijk hoef je alleen maar getallen te controleren die kleiner zijn dan of gelijk zijn aan de wortel van n.

Dit voegen we toe in de functie.

Om de wortel te kunnen gebruiken hebben we de math-module nodig.

Het getal a in de functie wordt berekend door eerst de wortel te berekenen, dan het gehele deel ervan nemen en dan nog 1 erbij optellen want we willen controleren t/m de wortel van n.

Ga na dat deze functie sneller is.

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 = 120.

Algemeen: 𝑛! = 𝑛 ∙ (𝑛 − 1) ∙ (𝑛 − 2) ∙⋯∙ 1

Dit kun je ook schrijven als: 𝑛! = 𝑛 ∙ (𝑛 − 1)!

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

 

De functie krijgt de vorm:

Als n=1 dan is de uitkomst 1

Anders is de uitkomst n*fac(n-1)

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)

Dit betekent: als a%b = 0 dan is b een deler van a. (b past een heel aantal keren in a want de rest is nul).

Begin met de definitie van de functie ispriem(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.

True en False kun je vinden met F2(a A #).

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).

Elementen kunnen ook van een ander type zijn bijvoorbeeld tekst of zelf weer een lijst.

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.

Voeg een regel aan het programma toe waarbij je het derde element afdrukt en ga na dat dit element de waarde 4 heeft.

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

Dit kun je vinden bij F1(Fns...) en dan List.

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 Fibonacci getallen te maken.

De rij van Fibonacci is: 1, 1, 2, 3, 5, 8, 13, ... waarbij steeds het volgende getal de som is van de twee vorige getallen.

Begin met de lijst L = [1,1].

Dan moeten we de eerste keer toevoegen L[0] + L[1]. Er geldt dan: L = [1,1,2]

De tweede keer voegen we L[1]+L[2] toe. Dit herhalen we steeds weer opnieuw.

Maak een programma dat de rij van de eerste 9 Fibonacci getallen maakt en gebruik hiervoor een for-loop.

Een mogelijk programma staat hiernaast. (de lijst heeft hierin de naam lst)

De loop wordt 7 keer doorlopen omdat we al met twee getallen beginnen.

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

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

Dit heet een twee dimensionale lijst.

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

Verander het vorige programma eerst zo dat de functie f(n) een lijst geeft met Fibonacci getallen.

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

Maak dan een for-loop waar bij steeds de lijst f(i) wordt toegevoegd aan a.

Zie hiernaast.

De lijst a 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 list. (dit kun je vinden met F1(Fns...) en dan Ctl.

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

Breid het programma uit met zo’n loop en druk alle lijsten uit a af.

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

Doelen :

• De plotlib module verkennen.
• Het scherm configureren en punten tekenen.

Om in Python grafische voorstellingen te maken is de ti_plotlib module nodig.

In deze module vind je opdrachten voor het tekenen van punten en lijnen en voor het configureren van het grafische scherm.

Start een nieuw Python programma.

Voeg nu eerst de ti_plotlib module in met bijvoorbeeld [ math ] en dan 5:ti_plotlib.

Kies voor 1:import ti_plotlib as plt.

Plot opdrachten moeten nu altijd voorafgegaan worden door plt.

Dit is een eigenschap van Python als je een module op deze manier invoegt.

 

We beginnen het programma met een leeg scherm. Daarvoor is de opdracht cls() die je kunt vinden in het ti_plotlib menu ([ math ]). Het voorvoegsel plt. wordt automatisch ingevoegd.

We gaan het punt (2,3) tekenen.

Daarvoor gaan we weer naar het ti_plotlib menu en nu naar het tweede tabblad (Draw). Daarin staat optie 6:plot().

Als je dit kiest wordt eerst gevraagd welk symbool je wilt gebruiken.

Kies optie 1:o. Dit zorgt straks voor een grote stip op het scherm.

Daarna kun je de coördinaten van het punt invullen, in ons geval (2,3).

Als laatste moeten we nog een opdracht toevoegen: show_plot().

(Weer te vinden in het plot-menu)

Deze laatste opdracht zorgt ervoor dat alle plot opdrachten worden uitgevoerd in een grafisch scherm.

Als het goed is zie je, nadat je het programma hebt uitgevoerd (met Run), een stip op het scherm.

Je kunt het grafisch scherm weer verlaten met de [ clear ] toets.

We passen het programma aan zodat het scherm er wat mooier uitziet.

We voegen rooster en een assenstelsel toe.

Zie hiernaast:
De meeste functies kun je vinden in het plot-menu onder het tabblad Setup.

De functie plt.color() staat onder het tabblad Draw.

De drie getallen staan voor rood, groen en blauw.

De volgorde is belangrijk: elke volgende tekenopdracht tekent over de vorige opdracht heen.

Hiernaast zie je dat er nog enkele regels aan het programma zijn toegevoegd.

Bedenk voordat je het programma uitvoert wat het effect zal zijn.

Voer het programma uit.

Je krijgt dan de figuur 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.

In het vorige oefenblad gebruikten we de functie plot(x,y,”...”) om een enkel punt te tekenen waarbij x en y de coördinaten zijn van het punt.

Als je meerdere punten wilt tekenen (voor bijvoorbeeld een grafiek van een functie) kun je voor de x en de y ook een lijst met coördinaten invullen.

Als lx de lijst met x-coördinaten is en ly de lijst met de bijbehorende y-coördinaten, dan kun je met de functie plot(lx,ly,”...”) deze punten tekenen waarbij de punten onderling verbonden worden.

We gaan de functie f(x)=x² – 4x plotten.

Start een nieuw Python programma en voeg de ti_plotlib module in.

We definiëren eerst de functie f.

Vervolgens maken we een lijst met x-coördinaten (lx).

En daarna een lijst met de bijbehorende y-coördinaten (ly).

We maken het programma af met dezelfde opdrachten als in het vorige voorbeeld.

Merk op dat er nu bij de plot() opdracht twee lijsten zijn ingevuld.

Als je het programma uitvoert zie je een grafiek van de functie f.

Het ziet er hoekig uit, maar dat komt omdat we voor x alleen hele waarden hebben gebruikt.

We gaan het aanpassen zodat het er wat vloeiender gaat uitzien.

We willen voor de x-coördinaten niet alleen hele getallen gebruiken.

Daarom passen we die lijst aan.

Stel bijvoorbeeld dat we in plaats van hele stappen stapjes willen nemen van 0.1.

Dan kunnen we de lijst aanpassen zoals hiernaast.

Let er wel op dat ook de range() getallen moeten worden aangepast.

Als i bij -100 begint willen voor de eerste x-coördinaat er -10 uit hebben.

Als je ook nog de plot() opdracht aanpast met een andere puntgrootte krijg je de grafiek zoals hiernaast.

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 gaan een grafiek tekenen van deze metingen en onderzoeken het verband tussen t en H.

Open een nieuw Python programma en voeg ti_plotlib module in.

Als eerste maken we twee lijsten met de gegevens uit de tabel.

Dan volgen drie opdrachten voor een geschikte schermindeling.

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

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

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

Als laatste weer de opdracht show_plot() om de grafiek te tonen.

Voer het programma uit.

Je ziet nu de grafiek met de punten uit de tabel weergegeven met een +

De punten lijken redelijk op een rechte lijn te liggen.

De beste rechte door de punten heet de regressie lijn.

We kunnen deze lijn tekenen met de opdracht plt.lin_reg(xlijst,ylijst,”center”,11).

Hierin zijn xlijst en ylijst de horizontale en verticale variabelen.

“center”,11 geeft aan dat de bijbehorende vergelijking gecentreerd op regel 11 wordt moet worden afgedrukt.

Het tijdstip waarop de waterhoogte 0 is kun je nu berekenen met de vergelijking
-4.64x+132.90=0

Je kunt de grafiek nog wat aanpassen door een titel toe te voegen en labels bij de assen af te drukken

De grafiek ziet er dan als volgt uit:

In deze les maken we kennis met de ti_system module waarmee data kan worden uitgewisseld tussen Python en TI-84 lijsten.

Doelen :

• Importeren en exporteren van lijsten.
• Lijsten plotten in Python.

De ti_system module maakt het mogelijk gegevens uit te wisselen tussen Python en de grafische rekenmachine via lijsten.

We gaan in Python een grafiek tekenen van de functie f(x)=-(1/2)x²+3x+1.

Maar eerst maken we een tabel van functiewaarden met behulp van lijsten in de grafische rekenmachine die we dan vervolgens in Python importeren.

Sluit, indien nodig, de Python toepassing en maak de lijsten L₁ en L₂ leeg.

Dat kan bijvoorbeeld met mem ([ 2nd ] [ + ]) en dan optie 4:ClrAllLists.

Ga daarna naar de list-editor ([ stat ] 1:Edit), en zet de cursor helemaal bovenaan in L₁, zoals hiernaast.

We vullen de lijst met de getallen 0 t/m 12 en een stapgrootte van 0.2.

Kies hiervoor list ([ 2nd ] [ stat ]) en daarna een naar rechts en dan optie seq (sequence).

Vul de parameters in zoals hiernaast.

Als de cursor op Paste staat en je drukt tweemaal op enter dan wordt L1 gevuld met de gewenste getallen.

Plaats de cursor helemaal bovenaan in L₂ en typ nu in: L₂ = -0.5L1²+3L₁+1.

Druk op [ enter ] en de list L₂ wordt gevuld met de functiewaarden.

(L₁ krijg je met [ 2nd ] 1)..

We maken nu een Python programma waarin we deze lijsten gebruiken om een grafische voorstelling te maken.

Om de lijsten in Python te importeren hebben we de ti_system module nodig.

Begin met een nieuw Python programma en voeg de module ti_system in.

(Dat kan bijvoorbeeld met [ math ]).

Voeg ook de module ti_plotlib in voor het tekenen van de grafiek.

Om de gegevens van de lijsten in Python te importeren gebruiken we de functie recall_list(“n”) uit de ti_system module (n is hierbij het lijstnummer).

Als je de eerste lijst bijvoorbeeld lx noemt, typ dan lx en open direct daarna het ti_system menu. Kies nu optie 2:var=recall_list(“name”).

Vul op de plek van name het getal 1 in.

Herhaal dit voor de tweede lijst ly maar neem nu 2 i.p.v. 1.

Als je de inhoud van de lijsten wilt bekijken kun je het programma nu uitvoeren en in de shell met vars de variabelen opvragen en afdrukken.

Om de grafiek te tekenen maken we het programma af met opdrachten uit het ti_plotlib menu.

Je kunt het uiteindelijke resultaat natuurlijk mooier maken door uit het ti_plotlib menu een kleur toe te voegen of een andere window instelling te kiezen.

In deze les maken we kennis met de ti_system module waarmee teksten op het scherm afgedrukt kunnen worden.

Doelen :

• Werken met display functies.
• Programma stoppen met clear.
• modulo rekenen met de % - deling

De ti_system module maakt het ook mogelijk teksten op vaste posities op het scherm te plaatsen.

We gaan een programma maken dat om je naam vraagt en daarna die naam op het scherm laat bewegen totdat we een toets indrukken.

Als we het programma straks starten willen met een leeg scherm beginnen.

De opdracht daarvoor, disp_clr() kun vinden in het ti_system menu.

Vervolgens moet het programma om een naam vragen.

We gebruiken de variabele “naam” voor de naam.

Om die in te voeren terwijl het programma loopt is er de opdracht input().

Die kun je vinden met F1(Fns...) en dan bij I/O.

Hiernaast zie je hoe je deze opdracht kunt gebruiken om de ingetypte tekst toe te kennen aan de variabele.

We maken nu een while-loop die telkens eerst het scherm leeg maakt en dan de naam een regel lager weer afdrukt. Het regelnummer noemen we r.

We laten de loop net zolang lopen totdat we de clear toets indrukken.

In de ti_sytem module staat hiervoor een opdracht: while not ecape().

Het scherm heeft 11 regels dus telkens als r = 11 moet er weer opnieuw bij regel 1 begonnen worden.

Hiervoor gebruiken we de modulo-deling (in Python is het teken hiervoor: %)

Zo geldt bijvoorbeeld 25 = 3 (je haalt een heel aantal keren 11 van de 25 af en kijkt wat je dan overhoudt).

Hiernaast staat het volledige programma.

De opdracht disp_at() drukt de tekst af op de aangegeven regel en lijnt die uit op de opgegeven manier (links, midden of rechts).

Ook deze opdracht staat in de ti_system module.

De ti-system module heeft nog een andere nuttige opdracht namelijk sleep().

Deze opdracht zorgt ervoor dat het programma het opgegeven aantal seconden pauzeert.

In het programma hiernaast wordt telkens 0.2 seconden gewacht voordat het verder gaat wat ervoor zorgt dat het tempo van de lus trager wordt.

(De opdracht sleep() vind je in ti_system helemaal onderaan, net zolang naar beneden scrollen totdat je er bent).

Om het nog een beetje mooier te maken kun je ook de cursor nog verbergen.

Dat kan met disp_cursor(0), ook in het ti_system menu.

In deze les maken we een Python programma dat verschillende weergaves geeft van de vrije valbeweging.

Doelen :

• Plotten van lijsten.
• Lijsten exporteren naar de List applicatie van de TI84

Een bal valt van een hoogte van 18 meter.

De hoogte van de bal als functie van de tijd kan worden benaderd met de formule h=18-(1/2)∙g∙t². Hierin is g de valversnelling (g≈9.81)

In het programma nemen we de formule: h=18-4.9∙t²

We meten gedurende twee seconden de hoogte in stappen van 0.1 seconden.

We maken twee verschillende soorten grafieken.

Eerst een die de positie van de bal weergeeft in de tijd.

Daarvoor geldt dat de x-coördinaat telkens dezelfde is.

Daarna een die de hoogte van de bal weergeeft als functie van de tijd.

We beginnen het programma met het importeren van de ti_plotlib module.

Daarna definiëren we drie lijsten. Een voor de x-coördinaat, een voor de y-coördinaten en een voor de tijd.

Bij de start zijn ze alle drie leeg.

We maken nu een for-lus waarin 20 keer de hoogte (h) wordt berekend en waarbij elke keer de tijd (t) met 0.1 seconde wordt opgehoogd.

In de lus worden steeds de lijsten aangevuld met de nieuwe waarden.

(De lijst met x-coördinaten bestaat uit alleen maar nullen.)

De startwaarde van t is 0.

We maken eerst een grafiek van de positie (x, y) van de bal in de tijd.

We gebruiken daarvoor de scatterplot uit het ti_plotlib menu.

De grafiek van de hoogte als functie van de tijd ziet er anders uit.

Op de horizontale as staan nu niet de x-waarden, maar de tijd-waarden.

We hebben daarvoor een andere vensterinstelling nodig.

Een handige optie is auto_window() uit het ti_plotlib menu.

Verder is in het programma nog een rooster getekend en is de puntenwolk (scatter) vervangen door de plot().

De grafiek zie er dan als volgt uit:

Als we nu nog drie regels toevoegen kunnen we ook de lijsten uit de rekenmachine gebruiken voor een grafiek.

Eerst moeten we de ti_system module importeren.

Daarin staat de functie store_list().

Met deze functie kun je lijsten exporteren naar de grafische rekenmachine.

Deze functie heeft twee argumenten. Eerst komt het nummer van de lijst uit de grafische rekenmachine (tussen aanhalingstekens). Daarna de lijst uit het Python programma.

Sluit de Python-app af en ga na dat de lijsten L₁ en L₂ van de grafische rekenmachine de waarden bevatten van de lijsten uit het Python programma.

Een plot van deze lijsten kan er dan uitzien zoals hiernaast:

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 vinden we 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.

Meestal heb je bij programma’s die de Hub gebruiken extra opdrachten nodig die in andere modules zitten. Daarom is het handig om die modules alvast in het programma in te voegen.

Een makkelijke manier hiervoor is bij het maken van een nieuw programma te kiezen voor een bepaald type.

Open een nieuw programma en kies bij het scherm waar je de naam moet intypen voor het type Hub Project met F3(Types).

Je ziet dan in de editor dat er twee modules zijn geladen.

Als je de ingebouwde led van de Hub wilt gebruiken moet je de opdrachten hiervoor apart toevoegen. Dat kan met het ti_hub menu.

Kies [ math ] en dan 6:ti_hub...

De ingebouwde led hoort bij de Built-in devices.

Selecteer deze en kies dan voor Color (de gekleurde led).

In de editor staat nu dat deze is geïmporteerd.

Dit betekent dat de opdracht is toegevoegd aan het menu.

Als je nu op [ math ] drukt zie je dat er een nieuwe regel aan het menu is toegevoegd.

De led kun je aansturen met deze nieuwe menu optie.

We geven de led een kleur en laten deze drie seconden knipperen met een frequentie van twee keer per seconde.

Let erop dat de Hub is aangesloten.

We gaan ook geluid toevoegen.

Ga weer naar het ti_hub menu en daarin weer de Built-in devices en kies nu voor sound.

In het modules-menu (via [ math ]) staat nu weer een nieuwe optie: Sound.

Kies hieruit tone(freq, time).

Laat nu 2 seconden een toon van 800 Hz horen.

Als laatste passen we ons programma aan door de toonhoogte te variëren.

Maak een loop die de frequentie laat lopen van 400 tot 2000 Hz met stappen van 100 Hz waarbij elke toon 0.1 seconde duurt.

Belangrijk hierbij is dat de tijd tussen twee opeenvolgende tonen ook minstens 0.1 seconde is per toon.

Je kunt hiervoor de opdracht sleep() gebruiken die in de time module staat.

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

Doelen :

• Het aansluiten van 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 allereerst een Ranger aan in poort IN1. (deze poort zit aan een van de zijkanten van de Hub).

Open een nieuw Python programma en kies weer voor het type Hub Project.

Om de Ranger te kunnen gebruiken moet hij worden toegevoegd aan het menu.

Ga daarvoor naar het ti_hub menu (bijvoorbeeld met [ math ]) en kies dan voor input devices en daaruit de Ranger.

Als je dan weer naar het modules-menu gaat dan zie je dat daar de optie Ranger is toegevoegd.

Voeg nu ook de sound optie toe (uit het ti_hub menu, Built-in devices)

Als het goed is ziet je programma er dan uit zoals hiernaast.

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

(Ga daarvoor naar het menu met [ math ] kies dan 1:var=ranger(“port”) en dan de gewenste poort. De cursor staat nu op de plek waar je de naam kan intypen.)

Het aflezen van de Ranger gaat met de opdracht r.measurement() waarbij r de gekozen naam is. (Ook dit kun je weer in hetzelfde menu vinden.)

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 opgeslagen in de variabele a en vervolgens afgedrukt.

De afstand wordt gegeven in meters.

Pas nu het programma aan zodat het de afstand blijft meten en afhankelijk van de uitkomst een toon laat horen (zoals een parkeersensor werkt)

Gebruik hiervoor de while not escape() lus (uit het ti_system menu).

Neem de volgende voorwaarden:

Als de afstand kleiner is dan 0.1 m dan moet de frequentie 1000 Hz zijn.

Tussen 0.1 m en 0.2 m is de frequentie 800 Hz.

Is de afstand groter, dan is de frequentie 400 Hz

Kies voor de toonduur 0.2 sec en wacht telkens 0.3 sec tot de volgende meting.

Een mogelijk programma staat hiernaast.

Je kunt nu ook experimenteren met de afstanden en de toonduur.

Je zou een soort instrument kunnen maken waarbij je met de hand de afstand kan variëren en op deze manier steeds een andere toonhoogte afspelen.

In deze les maken we een programma waarbij we de robotauto TI Innovator Rover laten rijden..

Doelen :

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

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

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

Als de Rover stopt moet het lampje twee seconden lang rood branden.

Open een nieuw Python programma en kies voor het type Rover (F3-Types op de openingspagina).

Er worden dan drie modules geladen.

Je kunt deze drie modules ook handmatig laden.

Begin met het aanzetten van het lampje.

De opdracht rv.color_rgb() kun je vinden in het Rover menu bij I/O en dan bij 2:Outputs

Nu moet de Rover gaan rijden totdat hij bij een object komt.

Een manier om dit te doen is als volgt:

Laat de Rover de afstand aan de voorkant meten.

In het programma wordt de gemeten afstand opgeslagen in de variabele a.

Geef de Rover de opdracht om een afstand van 10 meter te gaan rijden.

Meet, terwijl de Rover rijdt, telkens de afstand opnieuw.

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

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

De opdracht rv.ranger_measurement() kun je vinden in het Rover menu bij I/O en dan bij 1:Input.

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:

• Je gebruikt een TI-84 Plus CE-T Python Edition met OS 5.7.
• Je beheerst de beginselen van het programmeren in Python.
• De micro:bit is verbonden met de rekenmachine.
• Je hebt de instructies gevolgd voor het instellen van de micro:bit, zie: https://education.ti.com/nl/teachers/microbit

Deze procedure hoef je maar één keer te volgen, maar houd eventuele updates in de gaten.

Vanuit het rekenmachinescherm kun je controleren of de benodigde bestanden zijn geïnstalleerd:
Druk daarvoor op [2nd] [+] en kies dan
2: Mem Management > AppVars.
Hier kun je de bestanden vinden.

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.

Deel 1: Alien encounter

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

Begin in de Python-editor met een nieuw programma (F3<new>). We noemen het GREETING.

Als je in OS 5.7 <Fns…> Modul kiest verschijnt boven de F5- toets <Add-On>, waarmee je extra modules kunt vinden.
(Als dit niet op het scherm verschijnt moet je de rekenmachine updaten naar OS 5.7).

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

Kies <F4 : Add-On> en kies dan de micro:bit-module om from microbit import * naar het programma te kopiëren.

Als je nu opnieuw naar het modules-menu gaat (met <Fns…>Modul of met [math]) zie je een extra optie: micro:bit.
Telkens als je uit het micro:bit menu-opties kiest, wordt deze lijst uitgebreid.

Opmerking: de [math]-toets is een shortcut voor <Fns…> Modul maar toont niet het Add-On-tabblad.

Het micro:bit-submenu bevat alle opdrachten voor het programmeren van de micro:bit in aparte submodules.

 

Elk van deze menu-opties voegt een importopdracht toe aan het Pythonprogramma.
Dit komt omdat al deze opties in aparte modules zijn ondergebracht.

Selecteer nu het Display-menu…

In het Python-programma is nu een nieuwe regel toegevoegd:
from mb_disp import *

Open het [math]-menu opnieuw. Er is nu een Display-optie bijgekomen.
Selecteer Display…

Het Display-menu (zie hiernaast) bevat de opdrachten waarmee je het micro:bit-display kunt aansturen.
Dit display bestaat uit 5x5 rode leds in het midden van de micro:bit.
Selecteer nu .show(val)

De opdracht wordt ingevoegd als display.show()
Typ tussen de haakjes: “greetings earthlings” inclusief de aanhalingstekens.

Tip: Druk op [2nd] [alpha] om ‘alpha lock’ in te schakelen.
De aanhalingstekens staan boven de [+]-toets.

Voer het programma uit. De tekst wordt letter voor letter op het display getoond, maar het is moeilijk leesbaar.

Een betere manier om tekst weer te geven is met display.scroll(…). Ook deze opdracht staat in het display- menu.
Om het bericht sneller te laten zien kan een extra parameter worden toegevoegd:
display.scroll(“greetings earthlings”, 200).
Het getal 200 staat voor een wachttijd van 200 milliseconden tussen de letters. Standaard is dit 400, dus 200 laat het bericht tweemaal zo snel lopen.

Hiernaast zie je het resultaat met
display.scroll(“greetings earthlings”, 200).

 

Opmerking: Je kunt nog een tweede parameter toevoegen:
display.scroll(“greetings earthlings”, 200, wait).
Als wait = True wacht het programma met de volgende opdracht totdat het bericht volledig is getoond.
Als wit = False wordt de volgende programmaregel direct uitgevoerd.

Deel 2: Hartslag

In dit gedeelte laten we zien hoe je een plaatje op het display kunt tonen.
Maak een nieuw programma met de naam HART.
(Kies hiervoor Files – New)

Begin net als in het vorige onderdeel met het importeren van twee modules: from microbit import * from mb_disp import *

Om een afbeelding van een hart op het display te tonen gebruiken we de opdracht display.show(…) die weer staat bij [math] display… Als de cursor tussen de haakjes staat kun je uit het submenu [math] display… Images… HEART selecteren.

In het programma wordt dan de string “Image.HEART” ingevoegd.

 

Opmerking: In dit menu staan 36 plaatjes, maar je kunt ook zelf een afbeelding maken met var = Image(…).
Zie hiervoor de micro:bit-documentatie die online beschikbaar is.

Voer het programma uit. Dan zie je een hartvorm op het micro:bit- display verschijnen.
Het hartsymbool blijft op het display totdat je weer een andere opdracht geeft, ook als het programma gestopt is.
(Je kunt het verwijderen door op de reset-knop op de achterkant van de micro:bit te drukken.)

Ga terug naar de Python-editor en voeg de opdracht toe om het kleine hartsymbool weer te geven:
display.show(“Image.HEART_SMALL”).

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

We maken nu een lus om het hart te laten “kloppen”.
Voeg vóór de twee opdrachten de volgende opdracht toe:
while not escape():

Je kunt deze vinden in [math] ti_system…

Zorg ervoor dat de twee display-opdrachten beide inspringen.
(Dit zorgt ervoor dat beide opdrachten in de lus worden uitgevoerd.)

Voer het programma weer uit. Het hart klopt nu.
Je kunt het programma onderbreken met de [clear]-toets.

Je kunt de snelheid van de hartslag veranderen door een waarde voor de delay-parameter te kiezen.
Bijvoorbeeld zoals hiernaast

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

In deze les leer je de knoppen van de micro:bit gebruiken. Je maakt een programma dat het werpen met een dobbelsteen simuleert en de uitkomsten in een lijst opslaat. Daarna exporteer je de lijst naar de TI-84-omgeving waarmee je vervolgens een plot maakt.
Deze les bestaat uit drie delen:

• Deel 1: De werking van de knoppen onderzoeken;
• Deel 2: De knoppen gebruiken voor het genereren van data;
• Deel 3: Een lijst naar de TI-84 Plus CE-T Python Edition exporteren.

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;
• Exporteren van de data naar de TI-84 Plus CE-T Python Edition.

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 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-84-functies.

Deel 1: Knoppen onderzoeken
Start een nieuw Python-programma en noem het KNOPPEN.

Begin met from ti_system import *
(Dit kun je vinden in [math] ti_sysrem)
Importeer ook weer de micro:bit-module:
from microbit import *

Start daarna een while-loop: while not escape()
(zie hiernaast).

Belangrijk: ‘micro:bit import’ moet na de ‘ti_system import’-opdracht komen!

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

Om de micro:bit-knoppen te kunnen gebruiken moet je eerst een module importeren.
Plaats de cursor op de lege regel na de twee importopdrachten.
Druk op [math] en selecteer microbit… en kies nu voor Buttons en Touch Logo. Dit voegt de regel from mb_butns import * toe.

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

             if button_a.was_pressed():

         ◆◆print("knop 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 met <Fns…> Ctl.
button_a_was_pressed() vind je met: [menu] buttons…
Merk op dat er een button A- en een button B-submenu is.
Kies .was_pressed() onder het button A-menu.
print() vind je bij <Fns> I/O.

Je kunt nu het programma testen.
<Run> het programma.
Het lijkt alsof er niets gebeurt. Maar elke keer als je knop A indrukt verschijnt “knop A” op het scherm.

Druk op [clear] om het programma te stoppen en ga weer naar de Python-editor.

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.

<Run> het programma weer en druk op de knoppen A en B.
Het verschil is dat “knop A” pas wordt afgedrukt als je de knop weer loslaat, terwijl “knop B” steeds opnieuw wordt afgedrukt 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.

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.
Laat het getal afdrukken op het display van de micro:bit.
Voordat je verder gaat, kun je eerst zelf proberen om het programma te schrijven.

Om een willekeurig (random) getal te kunnen kiezen hebben we een functie nodig uit de random-module.
Deze module kun je vinden met [math] random…
Voeg in het vorige programma de regel from random import * toe.
De regel ogen = randint(1,6) geeft elke keer als knop A is ingedrukt de variabele ‘ogen’ een willekeurige waarde (1 tot 6).
(De functie randint() kun je vinden met [math] random…)

Het aantal ogen moet elke keer op het micro:bit-display worden getoond. Voordat we dat kunnen doen moet je eerst de display-module importeren. (Net als in de vorige unit.)
Voeg dus eerst toe: from mb_display import *
De regel display.show(ogen) toont het gegooide aantal ogen op het display van de micro:bit.
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.

Deel 3: 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.
We breiden het programma uit met drie regels.
Begin met een lege lijst waarin de uitkomsten worden opgeslagen, in dit programma heet die lijst: uitkomsten.
(uitkomsten = [ ])
Elke keer als je knop A indrukt moet de uitslag worden toegevoegd aan de lijst. Dit kan met uitkomsten.append().
(.append() kun je vinden met <Fns…> list)

Om de elementen van de lijst met uitkomsten op te slaan in een TI-84-lijst voegen we aan het eind van het programma nog een regel toe: store_list(“DOBBL”), Te vinden met [math] ti_system).
Deze functie slaat de lijst uitkomsten op in een TI-84-lijst met de naam DOBBL. Deze naam moet in hoofdletters en mag niet uit meer dan 5 letters bestaan.

<Run> het programma en druk een aantal malen op knop A en stop het programma weer door op de [clear]-toets te drukken.
Sluit de Python-app af en controleer dat de TI-84-rekenmachine nu een lijst heeft met de naam DOBBL.
(Druk hiervoor op [2nd] [stat]).
Met de ‘stat plot-optie van de rekenmachine kun je nu bijvoorbeeld een grafiek maken zoals hiernaast.

Opmerking: Vanwege de geheugenbeperking kan een rij met store_list() maximaal 100 elementen bevatten.

In deze les gebruiken we de lichtsensor van de micro:bit en slaan de data op in een TI-84 Plus CE-T Python Edition-lijst voor verder onderzoek.

Doelen :

• Het aflezen en weergeven van de lichtsensor op de micro:bit;
• Exporteren van de data naar de TI-84 Plus CE-T Python Edition;
• Meetgegevens van de micro:bit analyseren.

Met de leds van het display van de micro:bit kun je de lichtsterkte van de omgeving meten.
Deze leds kun je dus niet alleen voor uitvoer gebruiken maar ook voor invoer.

Start een nieuw programma met de naam LICHT en begin weer met de gebruikelijke import-regels en de while-lus.

Voeg nu de from mb_disp import *-regel toe om de display- functies te kunnen gebruiken.
In de while-lus plaatsen we de regel:
s = display.read_light_level()
(= .read_light_level() kun je vinden met [math] display…)
Voeg de regel print(“s =“, s) toe om te zien wat de resultaten zijn.

<Run> het programma richt de voorkant van de micro:bit op een lichtbron. Beweeg de micro:bit van en naar de lichtbron en kijk hoe de waarden op het TI-84-scherm veranderen.
Deze waardes variëren tussen 0 en 255.
Opmerking: Als de waardes niet variëren zoals hiernaast, kun je in de while-lus een sleep(100) commando toevoegen om het proces te vertragen.
Zoals verwacht zijn de uitkomsten kleiner als er minder licht gemeten wordt.
We breiden het programma uit zodat we de meetwaardes kunnen verzamelen en er een grafiek van kunnen maken.
Druk op [clear] om het programma stoppen en ga terug naar de <Editor>.

Creëer twee lege lijsten vóór de while-lus:
tijd = [ ] en lichtsterkte = [ ]
(Je kunt natuurlijk ook een kortere naam voor deze lijsten gebruiken (bijv. ls voor lichtsterkte).
Voeg ook de regel t = 0 toe. De variabele t telt het aantal metingen.

Voeg in de while-lus de regel t = t+1 toe om de tijd telkens met 1 te verhogen.
Opmerking: in Python kun je dit ook schrijven als: t += 1

Met de opdrachten tijd.append(t) en lichtsterkte.append(s) voeg je de waardes van t en s toe aan de lijsten tijd en lichtsterke.
.append( ) kun je vinden met <Fns…> List.

We willen de metingen elke seconde doen dus moeten we tussen twee opeenvolgende metingen 1 seconde wachten.
Dit kan met sleep(1000).
sleep( ) vind je met [math] micro:bit… Commands en gebruikt milliseconden.

Aan het eind van het programma, nadat de while-lus verlaten wordt, komen nog twee regels om de lijsten op te slaan als TI-84- lijsten.
We gebruiken weer store_list( ). (dit kun je vinden met [math] ti_system…)
De namen tussen de aanhalingstekens zijn de exacte namen die in de TI-84 omgeving gebruikt worden. Deze moeten in hoofdletters zijn en maximaal 5 letters bevatten.

<Run> het programma. Start met de micro:bit dichtbij een lichtbron en beweeg de micro:bit langzaam verder weg van de lichtbron totdat de lichtsterkte lager is dan 10.
Druk op [clear] om het programma te stoppen.

In deze toepassing maak je een programma waarmee je met de micro:bit-data verzamelt en tegelijkertijd de grafiek daarvan ziet veranderen. Je gebruikt daarbij o.a. de module ti_plotlib.

Doelen :

• Een programma schrijven voor het verzamelen van data met de BBC micro:bit;
• Een dynamische grafiek maken van de verzamelde data.

In deze toepassing gebruik je allerlei vaardigheden die in voorgaande units aan de orde kwamen:

• Het gebruik van de knoppen op de micro:bit voor het verzamelen van data;
• Het maken van een grafiek in Python;
• Het exporteren van data naar een TI-84-lijst voor verdere analyse.

Met de micro:bit kun je het werpen met twee dobbelstenen simuleren waarbij de uitkomsten op het display verschijnen.

De rekenmachine kan de grafiek van de som van de ogen dynamisch weergeven.

 

We maken een programma dat het werpen met de dobbelstenen simuleert en dat de data uiteindelijk met store_list() naar de TI-84 exporteert.

Start een nieuw programma met de naam DOBBELEN.

Je hebt een groot aantal Python-functies nodig, dus moet je hiervoor veel modules importeren:

 

• ti_system voor escape( )
• randomvoor randint( , )
• ti_plotlibvoor de Python-grafiek
• microbitvoor de micro:bit
• mb_dispvoor het micro:bit-display
• mb_butnsvoor de micro:bit-knoppen

We gebruiken knop A om te dobbelen en knop B om de dataverzameling te ‘resetten’ voor een nieuwe sessie.
Het is handig om een ‘setup’-functie te maken voor het initialiseren van het grafiekenscherm.

Begin het programma met def setup( ):

De functie ‘setup’ bevat de commando’s voor het instellen van het assenstelsel en je kunt deze vinden met [math] ti_plotlib.

Opmerking: De volgorde van de plt-functies is belangrijk, houd daarom de volgorde van het menu aan.
Het color-commando vind je in het Draw-submenu. We kiezen voor zwarte assen en paarse stippen.

Het hoofdprogramma begint met het maken van twee lijsten:
ogen = [0,1,2,3,4,5,6,7,8,10,11,12]
som = [0]*13

ogen[0] en ogen[1] kunnen niet voorkomen maar dienen om de x-as bij 0 te laten beginnen.

Om een scatterplot te maken heb je twee lijsten nodig.
ogen is de eerste lijst en som de tweede

Vervolgens wordt de al gedefinieerde functie setup( ) aangeroepen om het grafiekenscherm te initialiseren.

Ga nu verder met een while-lus:
while not escape():
◆◆ if button_a.is_pressed():
Als knop A is ingedrukt moet het volgende gebeuren:
• Twee keer een random getal kiezen;
• Beide uitkomsten op het display tonen;
• De som uitrekenen;
• De lijst som updaten;
• De scatterplot aanpassen.

De code staat hiernaast.

Als je het programma uitvoert kun je knop A ingedrukt houden, want er wordt alleen getest of de knop is ingedrukt.

Je kan het programma versnellen als je de twee display- commando’s weglaat.

Druk op [clear] om het programma te stoppen.

Je moet nog twee dingen doen:
• Knop B moet de functie van ‘reset’ krijgen:
Je moet de setup( ) aanroepen waardoor je het scherm wist en de lijst som zich opnieuw vult met nullen.
De lijsten moet je aan het eind exporteren naar de TI-84 voor verdere analyse. Hiervoor hebben we het
store_list( , )-commando nodig.
In het programma hiernaast gebruiken we store_list(“1”, ogen ) en store_list(“2”, som ). In de TI-84 zijn de lijsten dan opgeslagen in L1 en L2.

<Run> het programma en druk een groot aantal keren op knop A. Stop dan het programma met [clear] en sluit de Python-app weer af ([2nd] [quit]). Maak vervolgens een scatterplot van de L1, L2 -lijsten zoals hiernaast aangegeven.

Welk mathematisch model past bij deze plot?