Koda med TI: TI-Nspire™ CX

I denna första lektion kommer vi att titta på TI-Nspires programeditor för Python och hur man kan få ett Python-program att skriva ut en text.

Mål::

• Att kunna starta TI-Python-editorn
• Att förstå skillnaden mellan editorn och konsolen (shell)

Börja med ett nytt dokument, klicka på det och välj Lägg till Python och sedan Nytt ...

Alternativt välj Infoga och sedan Python och Nytt…

En dialogruta öppnas där du kan ange namnet på det program som skall skrivas och så kan välja en typ.

Skriv in ett namn, till exempel “test”, och tryck sedan på OK. Låt typen stå kvar som “Tomt program”.

Du är nu i den så kallade programredigeraren eller editorn där du kan skriva in och ändra i programkod.

Vi skall börja med ett enkelt program som bara skriver ut en text. Python-kommandot för att skriva ut en text heter print().

Du kan skriva detta kommando, men du kan också hitta kommandot i menyn. (Meny> 4: Inbyggda> 6: I/O> 1: print())

Vi skall nu skriva in den text som programmet skall skriva ut.

Viktigt: I de flesta programmeringsspråk så måste en text skrivas inom citattecken, och samma sak gäller även i Python. I editorn kan du se att texten är grönmarkerad. Detta är för tydlighetens skull och som ett hjälpmedel för att avluta med ett citattecken på rätt plats.

Programmet är nu klart.

För att kontrollera om programmet överensstämmer med Pythons syntax (grammatik) kan du kontrollera med Meny> 2: Kör> 2: Kontrollera syntax och spara. (Du kan också göra detta med Ctrl + B)

Om allt ör OK kommer programnamnet och ordet sparades visas på den översta raden. Det betyder att det inte finns några syntaxfel. Har du skrivit in något felaktigt så kommer en dialogruta att visa detta.

Om programmet inte hade några fel så kan du köra det genom om att öppna menyn och välja Kör (eller med Ctrl + R).

Nu öppnas ett nytt fönster där programmet körs och resultatet visas. Detta fönster kallas för Python shell – eller konsolen.

Du kan växla mellan editorn och konsolen (shell) med Ctrl Left och Ctrl Right.

Du kan gå tillbaka till redigeraren och ändra programmet, till exempel genom att lägga till en andra rad där du skriver in att Python skall skriva ut någon annan text. Om du kör programmet igen så kommer det nya resultatet genast visas i konsolen.

Tips till läraren: Du kan hoppa över syntaxkontrollen (Ctrl + B) och köra programmet direkt med Ctrl + R. Syntaxen kontrolleras då automatiskt.

I den andra lektionen kommer vi att titta på några av de olika datatyper som finns i Python.

Mål:

• Att kunna använda konsolen (shell)
• Att kunna hantera några olika datatyper

Börja med att skapa ett nytt dokument och välj sedan A: Lägg till Python och sedan 3: Shell

Du kommer nu in i Python-konsolen.

Skillnaden mellan konsolen (shell) och editorn är att i konsolen körs de kommandon du skriver omedelbart medan de i editorn körs först då du kör hela filen. Konsolen kan liknas vid det vanliga räknarläget och editorn vid den vanliga programeditorn i Nspire.

I det föregående programmet skrev vi en text. I dataterminologi sägs texter vara strängar. Dess datatyp är alltså sträng (string).

Du kan ta reda på en variabels eller ett värdes datatyp med funktionen type().

Funktionen type() finns under Meny> 3: Inbyggda. 5: Type > 6: type() men du kan också helt enkelt skriva in “type(“, det du vill finna typen på och så “)”.

Om du skriver in: type("Hej") i konsolen och trycker enter så visar Python vilken datatyp “hej” har.

Som vi kommer se så finns flera andra datatyper i Python.

Tips: I Python kan du använda enkla citattecken såväl som dubbla citattecken runt en sträng. Så "Hej” och 'Hej' betyder samma sak i Python.

Andra ofta använda datatyper är int (heltal), float (flyttal, tal som kan ha decimaler) och list (listor), där en lista är en sekvens av data. Observera att siffran 8, som visas till höger, är av typen heltal (int) men 8/2 är av typen float, även om 8/2 = 4.

Detta beror på att 8/2 är en division, och att vanliga divisioner i Python alltid ger ett flyttal, även om resultatet skulle kunna vara ett heltal.

Ibland kan det vara nödvändigt att ändra ett värdes datatyp. Till exempel kan du ändra resultatet av divisionen 8/2 till ett heltal med funktionen int().

Vi kan jämföra typen av 20/5 och av int(20/5).
I koden i textrutan kan vi också se exempel på att lagra värden i variabler. Vi lagrar tillexempel 20/5 i variabeln a.

Du kan också ändra texten “23” till ett heltal med samma funktion. På liknande sätt kan texten "35.9" ändras till flyttal med float("35.9") eller så kan vi ändra siffran 7 till en sträng med kommandot str(7)

Vi kommer att använda detta i nästa lektion.

I denna tredje aktivitet för kapitel 1 kommer vi att gå igenom skillnaden mellan ett program och en funktion.

Mål:

• Att använda variabler
• Att använda input()-kommandot.
• Att skapa funktioner

Det är ofta nödvändigt att kunna påverka programmets gång under körningen. Ett av kommandona som kan göra hjälpa oss göra detta är kommandet input(). Vi skall skapa ett program som först frågar efter användarens namn och sedan skriver ut namnet på skärmen.

Börja igen med ett nytt Python-program (Nytt dokument, Lägg till Python, Nytt…) och ge programmet något lämpligt namn.

Programmet skall börja att fråga efter användarens namn med hjälp av print-kommandot. Så behöver vi hämta in namnet med kommandot input. Sedan behöver vi spara det angivna namnet någonstans (tilldela det till en variabel). Vi kan tillexempel välja att lagra det i en variabel men namnet ”namn”.

Om vi vill skriva ut ”Hej” och så namnet på personen så kan vi göra detta genom att lägga ihop strängar (konkatenera strängar). Vi gör det med ett plustecken. Vi kan lagra resultatet i en ny variabel, ”text. Slutligen så skriver vi ut svaret till konsolen.

Mata in programmet och kör det.

Programmet kan göras lite kortare. Frågan vi skrev ut kan flyttas in i input-kommandot och sammanslagningen av texten kan flyttas in i print-kommandot

Input-kommandot returnerar alltid en sträng, det vill säga den ger alltid ifrån sig en sträng oberoende av vad som matas in. Det kan vara problematiskt om det du vill ha är ett tal. Så om vi vill ha ett tal så måste vi konvertera strängen till ett heltal (int) eller decimaltal (float).

Vi skall göra ett program som frågar efter ett nummer och sedan skriver ut kvadraten för det numret - så här behöver vi konvertera strängen till ett tal.

Programmet börjar med ett input-kommando och avslutas med ett print-kommando. Programmet visas till höger.

I Python anger du upphöjt till med två asterisk-tecken.

Förutom de inbyggda funktionerna i Python så kan du definiera egna funktioner.

Vi ändrar programmet så att beräkningen av kvadraten kommer att göras i en funktion.

Syntaxen (grammatiken) är viktig, så om du använder menyn minskar du risken för syntax-fel.

Gå till Meny, 4: Inbyggda, 1:Functions, 1: def function().

Detta ger oss en mall för att skapa egendefinierade funktioner.

Ersätt ordet funktion med det namn du vill ha på funktionen (till exempel kvadrat).

Ersätt ordet argumentet med det variabelnamn du vill ha på argumentet (till exempel x).

Ersätt ordet block med den kod du vill skall köras då funktionen anropas. (Du kan använda tab för att ta dig från ett inmatningsfält till nästa.)

För att tala om för Python vad som skall returneras (svaras) med så använder du kommandot return följt av det du vill skall returneras. I exemplet är detta det värde variabeln a har.

Mallen visar hur syntaxen ska se ut:

Som du ser så är alla rader inne i funktionen indragna (indenterade) med samma antal mellanslag. I Python så är all kod på samma nivå indenterade lika mycket. Detta skiljer sig från många andra programmeringsspråk, till exempel det ursprungliga språket i Nspire där motsvarande kod skrivs inom par av ord, Prgm och EndPrgm, eller som i JavaScript där ett motsvarande block av kod skrivs inom { och }.

Nästa steg är att anropa funktionen. I programmet till höger skrivs kvadraten på 20 ut när programmet körs.

Vi skall här titta lite mer på villkorssatser, alltså if-satser.

Mål:

• Att kunna använda villkorssatser.
• Att kunna villkorssatsers syntax i Python

I alla programmeringsspråk finns det något sätt att välja olika vägar genom programmet beroende på något villkor. Ett sådant sätt är med hjälp av villkorssatser i formen om A så B. Om villkoret A är sant så utförs B. Oftast finns det också något sätt att lägga till vad som skall göras om A inte är sant. Vi har då en sats i formen om.. så .. annars... I Python ser det ut som i rutan till höger.

Exempel:

Ett biluthyrningsföretag har följande erbjudande: Hyrespriset är 660 kr för de första 70 kilometerna plus 25 kr för varje extra körd kilometer. Vi ska göra ett program som frågar efter antal kilometer och sedan skriver ut motsvarande pris.

Starta ett nytt dokument och lägg ett Python-program.
Börja med att med hjälp av input-satsen frågan om antalet kilometer och ge värdet till en variabel k.

Kommandot input() returnerar alltid en sträng, men vi vill ha ett tal för k. Detta kan göras genom att ändra typen till ett heltal med funktionen int(). (Här antar vi att antalet kilometer är ett heltal)

De första två raderna i programmet kan nu se ut så här.

Lärartips: Om antal kilometer inte måste vara ett heltal så kan vi använda float(k) istället för int(k).

För att beräkna rätt pris måste programmet först testa om antalet kilometer är mer eller mindre än 70. Du kan använda if-strukturen för det. Du hittar den med meny > 4: inbyggda> 2: Kontroller > 2: if...else..

I mallen till höger ska villkoret skrivas direkt efter if där texten BooelskUttr står. Det första blocket innehåller de kommandon som skall köras om villkoret gäller. Kommandon som skrivs i det andra blocket körs om villkoret är falskt. Alla kommandon i samma block måste börja med samma antal mellanslag. Det är så Python skiljer på olika nivåer i programmet. Du ser också ett kolon i slutet av if-raden och på else-raden. Detta markerar för Python att det nu kommer ett block av kod.

Vi kan nu fylla i resten av if-mallen. Man skriver ≤ som <=. Resultatet av beräkningen måste naturligtvis också skrivas ut. Du kan köra programmet med Ctrl + R. När du kör programmet öppnas konsolen.

Tips: En rad inte är rätt indragen så kan man placera kursorn i början på raden och sedan trycka på tab. Skift-tab gör det motsatta och tar istället bort mellanslag.

Du kan också sätta in beräkningarna i en funktion. Vi tar bort input-satsen och låter k vara en parameter till funktionen istället. I exemplet till höger har funktionen getts namnet ”belopp”.

Var uppmärksam på syntaxen: Funktionsblocket är indraget i två mellanslag medan blocken i if-satserna nu måste vara indraga med två extra mellanslag.

När du kör det här programmet händer ingenting vid första anblicken. Men om du nu trycker på var-tangenten (eller Meny> A Variabler> 1 Variabler: Program för senaste körning) så ser du funktionen och du kan välja den.

Om du ger parametern ett värde och trycker enter så får du det beräknade priset.

Tips: Man behöver inte använda menyn. Man kan helt enkelt skriva in funktionsnamnet. I datorprogramvaran så kan man använda Ctrl-L

I detta avsnitt skall vi titta på hur man upprepar block av kod. Vi skall här använda så kallade for-loopar.

Mål:

• Att använda for-loopar.
• Att kunna syntaxen för for-loopar i Python.

En av styrkorna med datorer är dess förmåga att outtröttligt utföra i stort samma sak om och om igen. Ett kommando för att utföra detta är en for-loop. Vi skall skriva ett program som skall skriva ut kvadraten och kuben för de första åtta naturliga talen, 0 till och med 7.

Öppna ett nytt Python-program och ge det ett namn. I menyn under Inbyggda under Kontroller hittar du alternativen för en for-loop. Vi väljer det första alternativet

Ändra koden så att det blir som i exemplet till höger. Variabeln i är nu en så kallad räknare. Om inget initialvärde anges börjar loopen alltid med att i är 0. Så utför blocket av kod varefter i ökar med 1. Loopen körs åtta varv, så det sista värdet i får är 7.

Koden som vi kommer att skriva in i blocket kommer alltså att utföras åtta gånger då vi kör programmet, och i kommer då successiva ha värdena 0, 1, 2, 3, 4, 5, 6 och 7.

Observera kolontecknet i slutet av raden innan blocket börjar.

Vi vill skriva ut kvadraterna och kuberna så vi kommer att beräkna dem i loopen.

I Python skriver du upphöj till med två asterisker. Så 25 är skrivet i Python som 2**5.

I for-slingan måste vi beräkna och skriva ut i**2 och i**3 för varje nytt värde på i. Lägg till dessa rader och visa resultatet med Ctrl + R.

Vi kan också spara resultat i en lista. En lista i Python skrivs inom [ och ]. Låt oss skapa en lista av kvadrattal.

Vi börjar med en med en tom lista (En tom lista är en lista utan element). Varje gång loopen körs så skall vi lägga till ett nytt resultat i listan med hjälp av funktion av lite speciellt slag, en så kallad metod. Metoden heter .append. och den kan används för att lägga till ett element i en lista. Du hittar append under Meny > Inbyggda > Listor.

Ändra programmet så att den skapar en lista med element och så att listan skrivs ut efter loopen.

Print-kommandot ligger nu utanför for-loopen. Prova att flytta in den in i loopen. Det räcker att lägga till två mellanslag framför print-kommandot. Provkör.

Inom matematiken är fakultet-funktionen en mycket viktig funktion. Den är definierad så att man multiplicerar alla naturliga tal upp till och med ett givet naturligt tal med varandra. Vi har tillexempel att 5!=5·4·3·2·1.

Vi ska skriva ett program där vi definierar fakultet-funktionen.

Öppna en ny Python-fil (Meny 1: Åtgärder> 1 Nytt) och ge filen namnet fakultet. Skapa en funktion med namnet fakultet och en parameter n. Skapa en variabel f (för fakultet) och sätt den till 1. Skapa en for-loop som går från n till n+1. Du skall här använda det andra for-loops alternativet med ett start- och ett stopp-värde. Vi slutar med n+1 eftersom for-loopen avlutas då räknaren är lika med slutvärdet och att koden i loopen därmed inte körs för det värdet.

Inne i loopen skall du multiplicera f med i och ge svaret till f. På så vis multiplicerar vi successivt med 1, 2, 3 och så vidare upp till n. Avsluta med att returnera värdet på a. Tänk på vilken nivå return är i.

Kontrollera att du kan beräkna fakultet(4) blir 24. Testa gärna med något stor tal, tillexempel 1000.

(När du kör programmet kommer du in i konsolen där funktionen nu är definierad. Med var-tangenten eller med Ctrl + L kan du hämta funktionen.)

Tips: Skillnaden mellan return och print är att ett returvärde ges från en funktion och att returvärdet kan användas vidare i beräkningar. Man kan tillexempel skriva 2*fakultet(5) för att beräkna 2 gånger 5! Print-kommandot skriver till konsolen, men man kan inte på samma sätt direkt använda det som skrivits ut i vidare beräkningar. Däremot ger det oss möjlighet att skriva ut flera saker istället för att bara returnera ett värde.

I detta avsnitt skall vi titta på en annan slags loopar, while-loopar.

Mål:

• Att använda while-loopar
• Kunna while-loopars syntax i Python

Om du vill upprepa ett block av kod ett antal gånger, men du inte vet i förväg hur många gånger det blir så kan du använda en while ... loop. En while loop kan ses som att om ett visst villkor är sant så skall vi göra en viss sak om och om igen.

• Så länge det finns disk så diska.
• Så länge ett visst villkor gäller, fortsätt upprepa.

Vi skall skriva ett program som simulerar följande problem: Rulla en tärning och upprepa detta tills du får en sexa och räkna hur många gånger du behövde göra detta.

Du vet inte i förväg hur ofta du måste kasta -så här kommer while-loopen till pass.

Öppna ett nytt Python-program och ge det ett namn. Eftersom vi ska använda slumptal behöver vi en modul kallad random (slump). Den innehåller ett antal slumptalsfunktioner.

I Python är det vanligt att hämta hem moduler i början av programmet. Du hittar den här modulen i menyn Random och sedan alternativ 1 för att importera alla funktioner.

Tips: När du väljer ett namn till funktionen kan du också välja vilken typ av program det skall vara. Väljer du “Slumpartade simuleringar” så kommer modulen random automatiskt läggas till.

Vi kommer att använda två variabler i programmet. Variabeln "antal” som håller reda på antalet kast och variabeln "resultat" som håller reda på vad resultatet efter ett kast blir. (Du kan naturligtvis också välja andra namn)

Vi ger båda variablerna utgångsvärdet 0.

Lägg till mallen för en while.. med Meny> Inbyggda> Kontroller>while.. I det här fallet skall vi loopa så länge resultatet inte är like med 6. I Python skriver vi det som reultat!=6, där != betyder “inte lika med”. Vi har sedan en funktion, randint() som du hittar under meny>slumt>randint. Den returnerar ett slumpartat tal mellan två tal, inklusive talen. Så randint(1,6) kommer simulera en tärning.

Loopen innehåller två rader. I den första väljs slumpartat ett av talen 1, 2, 3, 4, 5 eller 6 och i den andra ökas antal med 1. Om resultatet av “tärningskastet” är lika med 6 avslutas loopen och antalet kast som krävdes skrivs ut. Om du kör programmet ett antal gånger visas förmodligen olika tal.

Tips: I konsolen kan du köra det senast körda programmet igen med Ctrl+R.

Men hur gör vi om vi vill göra experimentet 100 gånger och ta medelvärdet av resultatet?

Vi kan börja med att göra om det vi har gjort till en funktion som returnerar antalet varv.

(Du kan "flytta" hela funktionsblocket på en gång genom att välja det med shift-tangenten och piltangenterna och sedan trycka på tabbtangenten.)

Om du anropar denna funktion 100 gånger, successivt adderar resultaten och sedan delar summan med 100 får du det genomsnittliga antalet kast.

Börja med en variabel summa och ställ den till noll.

Sedan så gör vi en for-loop som skall loopa 100 gånger. Inne i den så anropar vi vår funktion, så sparar vi svaret i en variabel och så adderar vi detta till summan. Slutligen så skriver vi ut summan/100.

Mata in detta och provkör några gånger.

Om man vill prova med 1000 experiment så måste man ändra detta på två platser. Bättre är kanske att skapa en variabel som vi sätter till antalet försök, och sedan använder vi den på bägge platserna där vi har talet 100.

Ännu mer generellt är att placera andra delen av programmet i en funktion där parametern är antalet försök som skall göras och som sedan returnerar genomsnittet.

I den här applikationen ska vi skriva ett program som beräknar de eventuella reella lösningarna (eller lösningen) till en andragradsekvation.

Mål:

• Att använda if .. else ..
• Att definiera en mer komplex funktion

Ekvationen ax2 + bx + c = 0 har 0, 1 eller 2 reella lösningar. Vi ska skriva en funktion med talen a, b och c som argument

Funktionen skall skriva ut eventuella reella lösningar eller meddelas oss att inga reella lösningar finns. Vi kommer här använda den så kallade abc-formeln för att lösa ekvationen.

Skapa ett nytt Python-program och välj ett lämpligt namn på programmet. Python kan en hel del till att börja med, men för att utöka vad den kan så kan vi behöva importera så kallade moduler. Vi skall importera en modul kallad math för att Python att kunna beräkna kvadratrötter och en hel del andra matematiska funktioner.

Raden from math import * importerar alla funktioner från modulen math.

I första raden har vi lagt till en kommentar för att förklara vad vi gör. Komentarsrader i Python börjar med tecknet #, All text som kommer efter # på samma rad ignorerar av Python.

Vi fortsätter vi med att använda mallen för en funktion och så kan skapa en vi funktion som vi ger namnet andragrads_app. (I ett namn på en funktion eller en variabel så kan du använda _ mellan ord för att öka läsbarheten.)

Funktionen ska ha tre argument (a, b och c). Dessa skall lagra värdena för a, b och c från vår ekvation.

Vi börjar med att beräkna diskriminanten D.

Det finns nu tre möjligheter:
D <0 (inga reella lösningar), D = 0 (en lösning) eller D> 0 (två lösningar). Vi skall använda if .. elif .. else .. -strukturen för att skilja mellan de tre alternativen. Klicka meny > 4: inbyggda> 2: Kontroller > 3: if.. elif ..else..

Vi börjar med fallet D<0 då vi inte har några reella lösningar.

Så fyller vi på med fallet då D=0 då vi har en lösning. För att testa om D=0 behöver vi i Python, liksom många andra programmeringsspråk skriva D==0 . Detta för att ett = betyder tilldelning.

Det sista fallet som återstår är då D> 0. I så fall måste två lösningar beräknas.

Vi fyller i testerna (de så kallade Booleska uttrycken) och beräkningarna. Slutligen avslutar vi varje block med en utskrift av resultatet eller resultaten.

Tänk på hur du indenterar texten. Vi kan här se att texten inne i funktionen till att börja med är indraget med två mellanslag, och att texten inne i if-satsen är indraget med två mellanslag till.

Ordet elif är en förkortning av else if. Funktionen sqrt betyder square root, kvadratrot.

Det finns flera sätt att använda funktionen.

Du kan köra programmet med Run (Ctrl + R) och sedan i konsolen använda var-tangenten för att hämta funktionen och ange tre tal som argument.

Du kan också lägga till rader i programmet där du använder funktionen.

Ett exempel på det visa till höger.

Raden a = float (input (“a:“)) gör följande:
Texten “a:“ skrivs ut på skärmen. Talet vi skrivs in är kommer vara en sträng och den måste konverteras till ett decimaltal med float () -funktionen. Detta görs sedan för variablerna b och c varefter vår applikation anropas så att eventuella lösningar kan visas.

Kör programmet och testa med till exempel a=3, b=-7,

Här kommer vi titta lite mer på programmering i Python

Mål:

• Veta mer om villkorssatser
• True och False.
• Delbarhet

Ett primtal är ett positivt heltal som bara har två delare (1 och sig själv). Till exempel är 7 ett primtal eftersom talet bara har två delare (1 och 7), men 10 är inte primtal eftersom 10 är delbart med 1, 2, 5 och 10. Den minsta primtalet är 2. Vi ska skapa en funktion som kan avgöra om ett tal är ett primtal. Resultatet av denna funktion är sant om talet är ett primtal och falskt om talet inte är ett primtal.

Vi skall sedan hitta det hundradade primtalet med denna funktion.

Vi kommer här att använda en operation som skrivs med %-tecknet. I Python ger % resten efter division. Tillexempel är 20%3 lika med 2 eftersom 20/3 = 6 med en rest 2 (3 går in i 20, 6 gånger och du får 2 över).

Detta betyder att om a%b = 0 så är b en delare av a eftersom b går ett helt antal in i a, med rest 0.

Börja med att definiera is_prime(n) -funktionen.
Om n <2 kan den inte vara ett primtal. Då är resultatet falskt (False). Om n> = 2 kontrollerar vi om det finns en delare. Vi gör detta genom att testa om n är delbart med något mindre nummer (man behöver egentligen inte testa med alla mindre nummer. Vi kommer titta på det lite längre fram). Om så är fallet är resultatet falskt, annars är resultatet sant. (Du kan hitta True och False i menyn under inbyggda>Ops. True och False är så kallade Booelska värden och de kan användas i villkorssatser.)

Testa med lite olika tal. Fallet 2 är lite speciellt, eftersom For-loopen skall gå från 2 till 2 (inte inklusive). Detta innebär att loopen inte körs alls och att programmet istället fortsätter med raden efter, där programmet returnerar True

För att hitta det hundrade primtalet så skall vi skapa en while-loop. I loopen ska vi använda en räknare, antal, som ska räkna antalet funna primtal. Vi skapar en andra variabel, p, som skall innehålla det tal som skall testas. Vi sätter den till 1.

I while-loopen skall vi testa om i<100. Om så är fallet så ökar vi p med 1. Sedan skall vi testa om p är ett primtal. Om p är ett primtal så ökar vi antal med 1. Sedan loopar vi igen.

Funktionen is_prime (n) i programmet är mycket långsam. Om du till exempel vill beräkna 1000:e primtalet så tar det mycket tid, speciellt på handenheten (prova det inte ens).

Vi kan göra funktionen betydligt snabbare eftersom vi inte behöver testa alla tal upp till n inne i funktionen. Om vi testar med ett litet tal så testar vi automatiskt med ett större. Vi har tillexempel att eftersom 3 delar 27 så delar 9 talet 27 med eftersom 3·9=27. Detta innebär att vi bara behöver testa upp till roten ur n eftersom om vi delar med något större än roten ur n så blir resultatet mindre än roten ur n, som är ett tal vi redan testat.

Ändra detta i funktionen.

För att använda kvadratroten behöver vi lägga till matematikmodulen i början av programmet. Infoga denna modul med meny>matte>from math import *.

Kontrollera att programmet är snabbare nu.

Vi kan göra ytterligare ändringar i andra delen av programmet (den med while-loopen) med eftersom vi till exempel bara behöver testa vartannat tal efter p=3.

I detta kapitel skall titta på hur man skriver rekursiva funktioner i Python

Mål:

• Definiera rekursiva funktioner
• Rekursiv form kontra sluten form

En rekursiv funktion är en funktion som anropar sig själv. Ett bra exempel på en funktion som kan definieras rekursivt är fakultet-funktionen som vi tittat på tidigare.
Vi har exempelvis att 5!=: 5 ∙ 4 ∙ 3 ∙ 2 ∙ 1 = 24. Detta kan mer allmänt skrivas som n! = n ∙ (n -1) ∙ (n -2) ∙...∙ 1

I rekursiv form blir det att: n! = n ∙( n -1)! och att 1!=1.

Som du ser måste en rekursiv funktion ha någon slags slutvillkor, i detta fall att om n=1 så är svaret 1.

Vi ska skall skapa funktionen fakultet(n) där fakultet(n) = n*fakultet(n-1).

Funktionen har formen:
• om n = 1 är resultatet 1
• annars är resultatet n * fakultet(n-1)

Skapa ett Python-program där du definierar den här funktionen och prova sedan att beräkna några olika resultat.

En nackdel med denna funktion är att för stora värden på n är handenhetens minne inte tillräckligt. Ta reda på vad som är det största värdet för n som inte ger ett felmeddelande.

Som vi tidigare sett i kapitel 2, övning 2, så är ett annat tillvägagångsätt att använda en for-loop.

I funktionen skapar vi en variabel som vi sätter till 1 och där det nya resultatet är det gamla multiplicerat med räknaren (loop-variabeln) i en for-loop som går från 1 till n. (Kom ihåg range inte inkluderar sista talet.)

Definiera den här funktionen som fakultet1(n) och kontrollera att du med den funktionen kan beräkna 500! Kontrollera gärna om du kan få fram det svaret i det vanliga räknarläget i TI-Nspire.

Om du vill veta hur många siffror talet 500! har kan du göra detta i Python genom att först konvertera numret till en sträng med str() och sedan beräkna längden på den strängen med len().

Kontrollera att 500! har av 1135 siffror.

I denna övning ska vi titta på hur man kan använda listor i Python.

Mål:

• Göra listor
• Använda olika list-operationer

I Python så skriver man en lista som en uppräkning av element mellan hakparenteser, där elementen är åtskilda med kommatecken. Till exempel är [7,3,5] en lista med 3 element (tal i detta fall). Element kan också vara av en annan typ, till exempel text eller till och med en lista, som kan ses i exemplen till höger.

Öppna ett nytt Python-program och skapa en lista a med talen 1 till 10. Varje element i listan har ett index och det första elementet har index 0. Med a [3] får du elementet med index 3, som i det här fallet har värdet 4. Lägg till en rad i programmet där du skriver ut elementet med index 3 och kontrollera att detta element har värdet 4.

Som vi tidigare sett så kan du lägga till element i slutet på en lista med .append(). Du hittar detta i Meny > Inbyggda > Listor. Till exempel om a = [1,2,3], så gör a.append(5) att listan a nu är [1,2,3,5].

Vi ska använda detta för att göra en lista över ett antal Fibonaccital. Sekvensen för Fibonaccital börjar md 1, 1, 2, 3, 5, 8, 13, ... där successiva tal fås genom att addera de två föregående talen.

Börja med listan fib = [1,1]. Sedan måste vi lägga till fib[0] + fib[1] för nästa tal. Då har vi listan ib = [1,1,2]
Så lägger vi till fib[1] + fib[2]. Vi kan upprepa detta om och om igen med hjälp av en for-loop.
Skapa ett program som gör sekvensen för de första 10 Fibonaccitalen med hjälp av en for-loop. Ett möjligt program visas till höger.
Loopen körs åtta gånger eftersom vi bara behöver lägga till 8 nummer i listan [1,1].

Med lite ändring kan vi istället skriva ut de 100 första Fibonaccitalen. Ändra koden och testa att det fungerar.

En lista kan också bestå av element som själva är listor. Vi har då en tvådimensionell lista. Har alla dellistor samma antal element så har vi en matris.
Vi skall nu göra nu en tvådimensionell lista där varje element är en lista över de Fibonaccital vi hittills räknat ut, alltså en lista av listorna [1,1], [1,1,2], och så vidare.

Ändra först föregående program så att funktionen fiblista(antal) returnerar en lista med Fibonaccitalen.

Kontrollera först att fiblista(10) returnerar en lista med 10 Fibonaccital.

Skapa sedan en tom lista L=[].
Gör sedan en for-loop som anropar fiblista om och om igen och som lägger till resultatet till L.
Skriv sedan ut L.

Kontrollera att programmet här bredvid returnerat en lista med fyra dellistor.

Listan L från detta program består av listor.

Om vi vill skriva ut listorna under varandra är det möjligt med en for-loop.
Vi använder alternativet for i ni L. Du finner det under Meny > Inbyggda > Kontroller
I den här slingan går jag igenom alla element i listan L, så i kommer nu innehålla successiva sublistor.
Utöka programmet med en sådan slinga och skriv ut alla listor i L.

I det här kapitlet skall vi titta ti_draw-modulen som gör så att vi kan rita figurer med Python på TI-Nspire.

Mål:

• Att använda ti_draw-modulen
• Konfigurera ritytan och rita figurer

Du kan använda ti_draw-modulen för att rita grafiska figurer med hjälp av Python. I den här modulen hittar du kommandon för att rita punkter, linjer, cirklar, rektanglar och så vidare.

Starta ett nytt Python-program och välj typ: Geometri Grafik. Du kan också ladda den här modulen efteråt med Meny> Fler moduler> TI Draw.

Som standard är skärmens (ritytans dimensioner) 318 pixlar på längden gånger 212 pixlar på höjden med koordinaterna för det övre vänstra hörnet (0,0).Så “x”-axeln går år höger och “y”-axeln går nedåt.

Skapa ett program som ritar en cirkel centrerad i mitten av skärmen och har en radie på 100.Till höger kan du se hur du hittar kommandot för att rita en cirkel i menyn. Funktionen för detta är: draw_circle(159,106,100).

För att komma ut ur grafläget så att du kan ändra kod trycker du på ESC.

Ändra programmet så att 10 cirklar ritas med samma centrum, men vars radie varierar från 10 till 100.

I exemplet till höger har ett extra kommando lagts till. Detta kommando ställer in ritningsfärgen och du hittar den i TI Draw-menyn >Kontroller. VI har också använt range(från, till, steg) där värdet på loopvariabeln ökas med steg-storleken.

Tips: Du kan ändra färgen på en punkt eller en linje med funktionen set_color (). Denna funktion har tre argument. Dessa är RGB-värdena för färgen (röd, grön och blå). Dessa värden måste vara heltal (typ int) och ligga i intervallet [0-255]. Här ger (0,0,0) svart och (255, 255, 255) ger vitt.

Ett av kommandona i kontrollmenyn i ti-draw-modulen är set_window(). Detta gör att du kan ställa in start- och slut-värden för koordinataxlarna som skall användas i ritfönstret. Vi har valt värden så att origo blir i mitten på ritytan. Det är också viktigt att bredden är en och en halv gånger så stor som höjden för att bibehålla proportionerna.

Rita nu 20 cirklar med mitten i mitten av skärmen och vars radie varierar från 0 till 20.

När du kör det här programmet tar det lite tid att rita. Det beror på att ritmodulen måste kallas om och om igen. Det finns ett kommando, use_buffer(), som gör så att grafikkommandon inte utförs direkt utan istället lagras, “buffras”, tills allt ritande är klart och programmet avslutas, eller tills kommandot paint_buffer() körs. Du hittar dessa kommandon Dessa kommandon har lagts till i figuren till höger.

Tips: Use_buffer() placeras vanligtvis i början av programmet innan några grafikkommandon har utförts.

Försök göra ett program som skapar figuren här bredvid – eller något liknande.

Tips: Använd fill_rect() för att göra hela grafikfönstret svart och för att skapa en serie rektanglar inne i varandra. Använd en for-loop med negativ steglängd för att skapa allt mindre rektanglar inne i varandra.

En möjlig lösning finns på nästa sida.

Ett förlag till lösning visas till höger.

I detta kapitel ska vi bekanta oss med ti_plotlib-modulen och använda den för att rita figurer och grafer.

Mål:

• Att använda ti_plotlib-modulen
• Att rita en graf av en funktion

Med modulen ti_plotlib kan du rita diagram och koordinatsystem med Python. Starta ett nytt Python-program. välj nu att programmet ska vara av typen Plottning (x, y) & Text vid Ny.
Du ser att modulen ti_plotlib har infogats, men på ett något annat sätt än andra moduler. Till att börja med så kommer programmet innehålla lite extra kod.

Dessutom måste alla kommandon och funktioner i modulen starta med plt. Detta sker automatiskt om du hämtar dem med hjälp av menyn.

Vi börjar med ett rutnät och ett koordinatsystem med ett rutnät. Vi skall nu titta på den kod som automatiskt lades till.

Det första kommandot, plt.window(xmin,xmax,ymin,ymax), gör samma sak som fönsterinställningar i Nspires vanliga grafläge. Du kan här skriva in värden för koordinataxlarnas start- och slut-koordinater. Värdena -10 till 10 respektive -6.67 till 6.67 motsvarar Nspires defaultvärden i vanliga grafikläget. Om ni inte har med detta kommando så är det dessa värden som kommer att användas även här.

Nästa kommando, plt.grid, låter oss ställa in avståndet mellan linjerna i koordinatsystemet. Först i x-led, sedan i y-led. Slutligen kan vi välja formatet på linjerna.
Sista kommandot, plt. axes, används för att ange om axlar skall visas eller inte.

Ordningen på kommandona är viktig här. Se till exempel vad som händer när du byter kommandona plt.grid() och plt.axes(). Titta på hur axlarna ser ut.

Som du kan se så har en punkt markerats i diagrammet. Du hittar kommandot för att lägga till en punktmarkering under meny>TI PlotLib>draw>plot. Punktstilen är “o” för ett större märke och “+”, ”x” respektive ”.”, som ger det som förväntas. Lägg till en rad som ritar ut en större punkt med koordinaterna (5,3).

Vi skall plotta funktionen f(x)=x2 – 4x.
Börja med ett nytt Python-program och importera ti_plotlib-modulen.
Definiera funktionen f.

Det vi sedan skall göra är att skapa två listor, en med x-koordinater och en med y-koordinater. Vi skulle kunna göra detta med en for-loop, men Python kan göra det enklare för off genom att vi kan sätta in en slags for-loop direkt i listan. När vi skapar koordinaterna för x, cx, så kan vi skriva cx=[x for x in range(-10,11)]. Detta betyder, skapa en lista där vi låter x anta de värden som for x in range(-10,11) ger, det vill säga [-10, -9, -8, .... , 7,8,9,10].

Nästa steg är att skapa y-koordinater från våra x-koordinater. Vi kan göra detta med [f(x) for x in cx].

Vi lägger sedan till kommandon för rutnätet och för koordinataxlarna.

Vi ritar grafer genom att plotta ett antal punkter som sedan sammanbinds med räta linjer.
Ti_plotlib-modulen har ett kommando för detta, plt.plot(x-list, y-list, "märke"), där x-list är en x-koordinat eller en lista med x-koordinater och y-list är en y-koordinat eller en lista med y-koordinater. Märke är punkttypen som nämndes tidigare.

Att plotta diagrammet är nu möjligt med det ovan nämnda kommandot och de koordinater vi räknat ut tidigare.

Provar ni detta så kommer ni se att grafen ser ganska kantig ut. Ni kan ändra detta genom att stega oss genom dubbelt så många punkter och sätta x-koordinaten till x/2 såsom i exemplet till höger.

Anledning att vi behöver krångla till det på det här viset istället för att sätta steglängden till 0.5 i range-kommandot är att range-kommandot bara klarar av att arbeta med heltal.

Vi kan göra detta ännu snyggare genom att ändra antalet steg till 10 gånger fler, såsom i exemplet till höger.

Tips: Listorna skapas med en för loop inne i en lista. Du hittar detta under meny>Inbyggda>Listor. I den andra listan använder vi oss av möjligheten att med for-in stega off igenom en redan existerande lista där loop-variabeln sätts till värdet av element efter element i listan cx.

Här skall vi titta på hur man ritar ett spridningsdiagram och hur man finner en regressionslinje.

Mål:

• Att rita spridningsdiagram
• Att hitta regressionslinjer

Vi ska analysera data från en översvämning.
Under en översvämning i ett område mäts vattennivån varje timme.
Resultaten visas i följande tabell:

Här är t tiden i timmar och h djupet i cm.

Vi ska göra ett program som skall rita ett spridningsdiagram över ovanstående data och sedan finna den räta linje som passar punkterna bäst.

Öppna ett nytt Python-program(meny>Åtgärder>Nytt..) och lägg till ti_plotlib-modulen.

Skapa två listor med värdena från t och D.

För diagrammet behöver vi ett lämpligt koordinatsystem. Med kommandot plt.window () kan du justera fönsterinställningarna. Lägg även till att axlarna skall synas. Med plt.color kan du ställa in färgen som punkterna skall ha. Vi skall ha blå punkter, så vi använder plt.color(0,0,255).

Slutligen så använder vi funktionen plt.scatter(t,D,”x”) för att skapa vårt spridningsdiagram. Parametern “x” i slutet markerar att punkterna skall visas som små kryss. Du hittar scatter under meny>TI PlotLib>Draw

Om du nu kör programmet borde du ha fått fram en graf liknande den till höger.

Punkterna verkar ligga ganska nära en rät linje. Den linje som passar bäst enligt den så kallade minstakvadratmetoden kallas för regressionslinjen. Vi kan rita denna linje med kommandot plt.lin_reg (t, D, ”center”).

Ordet "center" indikerar att ekvationen vi får fram placeras centrerad (i horisontalled) på skärmen.

I exemplet har några extra kommandon lagts till.

Vi får nu fram att regressionslinjen har ekvationen

• y=-4,6x + 132,9

Vi kan använda denna ekvation till att exempelvis beräkna tiden tills vattendjupet är 0 med ekvationen

• -4,6x + 132,9 = 0

Talen -4,6 och 132,9 har avrundats till en decimal. Dessa bägge värden lagras i variablerna plt.m och plt.b som du hittar under meny>Ti PloLlib>Egenskaper.

Om du tar fram dessa variabler i konsolen så kan du där se dem med fler decimaler. Du kan också använda dem för vidare beräkningar i programmet såväl som i konsolen.

I den här lektionen kommer vi att bekanta oss med ti_system-modulen med vilken data kan utbytas mellan Python andra TI-Nspire-applikationer.

Mål:

• Exportera värden till Nspire
• Anropa funktioner i Nspire.

Ti_system-modulen gör det möjligt att utbyta data mellan Python och andra applikationer. Du kan utbyta variabler, listor och funktionsvärden.

Öppna ett nytt dokument och välj en miniräknarsida (alternativ 1). Definiera en funktion, till exempel f (x): = x2.

(Observera att när du definierar en funktion i räknarläget på TI-Nspire så måste du använda := tecknet.)

Lägg till en ny sida i dokumentet (CTRL + Doc (+Page)) och välj en Python-sida av typen Datadelning. Med detta val importeras modulen ti-system automatiskt. (Denna modul finns också i menyn under Meny>Fler moduler>TI system och sedan alternativ 1.)

Menyn ti_system innehåller funktionen eval_function(), under meny>Fler moduler.
Denna funktion har två parametrar. Det första är namnet på den funtion i Nspire du vill anropa (i vårt fall “f”) och den andra är det värde du vill skicka över till funktionen.
Kontrollera att programmet returnerar 25.

Vi kan använda detta för funktioner som inte finns i Python men som finns i TI-Nspire. Vi ska titta på två sådana funktioner. Den första är att beräkna den största gemensamma delaren till två tal, gcd(a,b).

Den andra är att kontrollera om ett tal är ett primtal.

Vi börjar med att gå tillbaka till räknarsidan. Vi kan göra det med ctrl och uppåt-pil och sedan välja sidan.
Väl där så definierar vi funktionen g(x):=gcd(x,y)

Gå tillbaka till Python-sidan och definiera funktionen gcd(a,b)
I exemplet till höger börjar funktionen med ) store_value(“y”, b).  Detta beror på att eval_function() i Python endast kan hantera funktioner med en parameter. Andra värden som också måste också vara kända kan anges med store_value(). I detta fall ger vi y ett värde innan vi anropar funktionen med hjälp av eval_function().
Funktionen store_value() finns i Ti_system-menyn.

Kontrollera att du kan använda Python för att beräkna gcd för två på detta sätt.

I följande exempel använder vi funktionen isprime() i TI-Nspire. Denna funktion returnerar true om in-värdet är ett primtal och falskt om det inte är primtal.

Funktionen eval_function() i Python kan inte hantera värden av denna typ (Boolean), men den fungerar bra om beräkningsresultatet är ett tal. För att få detta att fungera så definierar vi på räknarsidan en funktion p(n) sådan att resultatet är 1 för ett primtal och 0 om det inte är det.

I Python ser funktionen ut som den till höger.
Vi har också lagt till några rader som skriver ut en lista med alla primtal under 100.

I den här lektionen ska vi fortsätta titta på ti_system-modulen och hur vi kan använda den för få ett program att reagera på tangenttryckningar.

Mål:

• Detektera vilken tangent som tryckts ner

Modulen ti_system innehåller även funktioner som kan läsa av tangentbordet.

Vi ska använda detta till att skapa ett program som gör att du med piltangenterna kan flytta en liten cirkelskiva över skärmen.

Starta ett nytt Python-program och importera ti_system-modulen och ti_draw-modulen. (Båda finns i menyn under Fler moduler.)

Vi börjar med en röd cirkelskiva mitt på skärmen.
Skärmen är 318 pixlar bred och 212 pixlar hög med ursprunget i det övre vänstra hörnet, så mitten på ritytan får då koordinaterna (159,106). Kommandot fill_circle() hittar du under meny>Fler moduler>Ti Draw>Form

Funktionen get_key() från ti_system-menyn kontrollerar om en tangent har tryckts in och i så fall är resultatet namnet på den tangent som har tryckts, så den returnerar med andra ord en sträng. Är ingen tangent nedtryckt så returnerar funktionen en tom sträng.
Vi ska lagra resultatet av get_key() i en variabel, låt oss ge den namnet tangent. Vi börjar med att sätta variabeln till en tom sträng, tangent = ””. Därefter skapar vi en while-loop som i varje varv anropar get_key(). När man trycker esc-tangenten så ska loopen avslutas.

Nu ska vi lägga till kod som kontrollerar om en piltangent har tryckts ner, och i så fall ska motsvarande koordinat ändras så att cirkelskivan flyttas i motsvarande riktning.

Om du testar programmet så ser du att det kanske inte är helt så som vi tänkt oss. De gamla cirkelskivorna finns kvar. Dessutom kan vi få cirkelskivan att vandra utanför skärmen.

För att säkerställa att cirkelskivan inte hamnar utanför skärmen bör koordinaterna inte vara för stora eller för små.
Du kan göra detta med funktionerna min() och max():

• min (x, y) returnerar det mindre av de två talen och
• max(x, y) returnerar det större värdet.

Så om x-koordinaten blir mindre är 5 (cirkelskivans radie) så sätts den till 5 så att cirkelskivan hamnar vid vänsterkanten. Vi gör på liknande sätt i de andra ifsatserna.

Om vi bara vill se den senaste cirkelskivan så kan vi tillexempel tömma skärmen med kommandot clear() innan vi ritar en ny cirkel.

Provar ni programmet med denna ändring så märker ni att skärmen flimrar hela tiden. Detta eftersom skärmen rensas och sedan ritas om även när ingen knapp trycks in.
Du kan förhindra detta genom att ge funktionen get_key() något in-värde, tillexempel 1. Detta gör att get_key() funktionen väntar på en tangenttryckning innan den returnerar ett värde.
Detta gör att programmet väntar på att en tangent ska tryckas och loopen kommer därmed temporärt stoppas.

(Vi skulle kunna lösa detta på andra sätt. Vi exempelvis kunna spara de gamla koordinaterna och bara anropa clear och fill_circle då positionen för cirkelskivan faktiskt har ändrat. (Vi kan testa det med en if-sats) Fördelen med detta är vi kan låta programmet göra annat då programmet väntar på tangenttryckningar. Nackdelen är mer komplicerad kod.)

I den här lektionen introduceras vi till ti_image-modulen som kan användas för att redigera bilder.

Mål:

• Importera bilder
• Bildbehandling

Modulen ti_image gör det möjligt att importera och redigera bilder med hjälp av Python.

Vi skall använda bilden på ballonger som du kan se till höger. Bilden finns med i Nspire-programvaran, men du kan också kopiera bilden från detta dokument.

Vi ska skapa ett program som omvandlar den här bilden till en bild i gråskala.

Denna uppgift måste helt eller delvis utföras i datorversionen av TI-Nspire.

Öppna ett nytt Python-program och importera ti_image-modulen.
(Detta kan till också göras genom att välja programtypen "Bildbehandling" – men då får du med lite mer som vi inte behöver jist nu.)

För att redigera en bild i Python måste den bilden vara på en anteckningssida.

För att lägga till en bild på en anteckningssida så måste vi använda datorprogramvaran. Det fungerar inte på handenheten.
I programvaran lägger du till en anteckningssida i det aktuella dokumentet.

Sedan kan du importera en bild till den här sidan med menyalternativet "infoga - bild".

(Du kan använda en valfri bild eller kopiera bilden från det här dokumentet.)

Du kan nu ladda över dokumentet till handenheten eller fortsätta på datorn.

Nu när bilden finns på anteckningssidan måste du ge den ett namn. Flytta markören över bilden och använd ctrl-meny (eller ctrl-klicka eller högerklicka) för att få en popup-meny. Välj sedan 5: Namn på bild och ge bilden ett namn (till exempel Ballong)

Gå tillbaka till Python-sidan för att fortsätta skriva programmet. Vi kan lagra bilden i en variabel med kommandot load_image(). Du hittar detta i Meny>Fler moduler >TI-image> load_image(). I det här exemplet kallar vi variabeln där vi lagrar bilden ”bild”.

Om du nu skriver bildens variabelnamn följt av en punkt så dyker det upp en meny med ett antal val.
En av dessa val är show_image().

Vi väljer det alternativet och anger koordinaterna (0,0).

Detta betyder att bildens övre vänstra hörn hamnar 0 pixlar från vänster och 0 pixlar nedåt.

Om du nu kör programmet så visas bilden.

För att redigera bilden behöver vi bildens dimensioner i pixlar.
Du kan finna dessa med bild.w för bredden och bild.h för höjden.

Vi gör nu två loopar i varandra som tillsammans går igenom alla pixlar och beräknar motsvarande gråskalevärde för varje pixel, varefter vi skriver in de nya värdena in i bilden.

Med kommandot get_pixel (i, j) får du färgerna från motsvarande pixel givet som en slags lista (en så kallad tuple) som består av tre element, (röd, grön, blå).

För varje pixel beräknar vi medelvärdet av dessa tre tal och så ger vi alla tre färgerna detta värde. (Tre lika färgvärden ger en grå nyans)

Slutligen skriver vi ut bilden på skärmen igen.

Programmet tar en stund att köra. Så länge det körs så står det Körs... över ritfönstret.

(Ur grafisk synvinkel vore det bättre att istället beräkna snittet med gr=int(sqrt((c[0]**2+c[1]**2+c[2]**2)/3)), det så kallade kvadratiska medelvärdet. Detta gör så att ljusstyrkan på bilden bättre överensstämmer med originalet. Tänk på att du behöver importera matematikmodulen om du vill prova detta.)

I den här lektionen kommer vi att använda TI-Innovator™- Hub i ett Python-program.

Mål:

• Använda ti_hub modulen
• Några grundläggande användningar av hubben

I ti_hub-modulen hittar du kommandona för att kommunicera med TI-Innovator-hubben från Python.

Vi ska skapa ett program som tänder den färgade lysdioden i hubben och använder den inbyggda högtalaren.

Anslut hubben till handenheten eller till datorn via ingången märkt DATA

Öppna ett nytt Python-program där du inte väljer någon typ.
För att använda Innovator-hubben behöver du ti_hub-modulen.
Välj från menyn TI Hub och sedan alternativ 1: från ti_hub import *.
Du har då tillgång till alla hub-funktioner.

Hubben har en LED som kan lysa i alla färger (r,g,b). Du kan sätta färgen med komandot color.rgb(r,g,b). Du hittar det under meny>TI Hub>Hubb inbyggda enheter>Färgutgång>1: rgb(red, green, blue).

Kommandot blink() i samma meny har två parametrar, blinkfrekvens och hur lång tid det ska blinka.

I exemplet till höger har röd färg valts och att lampan ska blinka i 3 sekunder med en frekvens av två gånger per sekund.

Vi kan också lägga till ljud.
I ti_hub-menyn kan du välja meny>TI Hub>Hubb inbyggda enheter>Ljudutgång. där kan du välja tone(frekvens, tid)Spela nu en 800 Hz-ton i 2 sekunder.

Vi kan variara variera tonhöjden.
Skapa en slinga som kör frekvensen från 400 till 2000 Hz i steg om 100 Hz där varje ton varar i 0,2 sekunder.

När du kör detta program märker du att tonerna inte varar 0,2 sekunder.
Det är viktigt att tiden mellan två på varandra följande toner också är minst 0,2 sekunders. Du kan använda kommandot sleep() för detta.

I den här lektionen ska vi titta på hur man kan läsa in data från externa sensorer.

Mål:

• Ansluta externa sensorer
• Använda avståndssensorn.

Förutom de inbyggda enheterna kan du också ansluta externa in- och utdataenheter till hubben.
Vi ska göra ett program som kommer att använda en en avståndssensor (Ranger) för att mäta avståndet till ett objekt.
Programmet ska också producera ett ljud vars tonhöjd beror på det uppmätta avståndet.
Anslut avståndsensorn till port IN1 – som finns på ena sidan av hubben och anslut hubben till en handenhet eller dator.

Öppna ett nytt Python-program och importera ti_hub-modulen.
För att kunna använda avståndsmätaren så måste vi ange vilken port den är ansluten till och vi måste ge den ett annat namn.
Från menyn TI Hub väljer du Lägg till inmatningsenhet och sedan väljer du Ranger.
Var = ranger (“port”) visas på skärmen.
Markören är nu där du kan ange namnet.
Skriv in ett namn (till exempel rg) och ange vilken port Ranger är ansluten till (IN1 i detta fall).

Att läsa data från avståndsmätaren görs med kommandot rg.measurment(). Du kan enkelt ange hitta detta genom att skriva variabelnamnet, rg, omedelbart följt av en punkt.
Om du vill använda det uppmätta värdet kan du lagra det i en variabel, till exempel a.

Om du kör programmet till höger kommer det uppmätta avståndet visas.

Det uppmätta avståndet är i meter.

Ändra programmet så att det kontinuerligt mäter avståndet och avger en ton beroende på resultatet (som en parkeringssensor fungerar).
Använd en while-loop för detta.

Om avståndet är större än 0,4 m ska frekvensen vara 1000Hz.
Mellan 0,2 m och 0,4 m. ska frekvensen vara 800Hz.
Mellan 0,05 m och 0,2 m ska frekvensen vara 400 Hz.
Om avståndet är mindre än 0,05 m (5 cm) ska programmet stoppas.

Välj 0,2 sek för tonens längd och vänta 0,3 sek för nästa mätning.

Ett möjligt program visas till höger.

Du kan också experimentera med avstånd, frekvenser och tonlängder.

I den här lektionen ska vi göra program där vi låter en Rover köra.

Mål:

• Programmera Rovern.
• Använda Roverns avståndssensor.

För att programmera Rovern behöver du ti_rover-modulen.
Denna modul innehåller alla kommandon du behöver för att programmera Rovern.

Öppna ett nytt Python-program och importera modulen ti_rover.
I bilden till höger ser du: import ti_rover as rv.
Detta innebär att varje Rover-kommando måste börja med rv.
Detta sker automatiskt när du hämtar kommandona från menyn.

Först skapar vi ett program som gör att Rovern kör runt i en kvadrat med sidorna 50 cm.

Avstånd anges i decimeter.

Vi ska nu göra ett program som gör att Rovern körs tills avståndet till ett objekt (till exempel en vägg) är mindre än 10 centimeter.
Under körning ska lampan på Rovern vara grön.
När Rovern stannar ska lampan vara röd i två sekunder.

Vi behöver importera tidsmodulen. Tidsmodulen (Time) finns i menyn under Fler moduler.

Börja med att sätta på ljuset. Vi gör det med kommandot rv.color_rgb() som finns under TI Rover-menyn>utdata.

För att ta fram avståndet från Rovens till närmsta objekt använder man rv.ranger_messurment() som du kan finna under meny>TI Rover>Indata. Lagra mätvärdet i en variabel, säg a.

Rover ska nu köra tills avståndet till ett objekt är mindre än 10 cm.
Vi skickar ett kommando till Rovern att köra sig en relativt lång sträcka, säg 10 m.
Sedan skapar vi en while-loop där vi vi mäter avståndet om och om igen. Detta gör vi tills avståndet blir mindre än 0,1 m.
När loopen har avslutats skickar vi ett stop-kommando till Rovern.

För att ljuset ska bli rött i två sekunder måste ytterligare tre rader läggas till.
Först får ljuset rätt färg.
Då måste du vänta två sekunder.
Och slutligen måste ljuset stängas av igen.

I denna övning ska vi skriva ett Python-program som ska styra displayen på micro:bit olika sätt. Övningen består av två delar:

• Del 1: Möte med utomjordingar,
• Del 2: visa bilder

Mål:

• Att styra diplayen på micro:bit med metoden .show(), .scroll() och .show(image).
• Att styra displayens hastighet med kommandot sleep(ms)

• Se till att din TI-Nspire CX II-T har OS 5.3 eller högre.
• Du är enkelt att programmera i Python, när du har slutfört kapitlen 1 till 5 innan du börjar med detta kapitel.
• din micro:bit är ansluten till din TI-Nspire CX II-T
• Du har följt installationsanvisningarna och gjort filöverföringarna beskrivna i denna guide: https://education.ti.com/sv/larare/microbit

Denna installationsprocess behöver bara göras en gång, men håll dig regelbundet informerad om uppgraderingar.

Om installationen har gjorts korrekt och allt fungerar så ska din
micro:bit se ut som i bilden till höger. Displayen, som består av 25 lysdioder ska visa Texas Instruments logotyp och en av lysdioderna ska lysa lite kraftigare. Den motsvarar positionen för Dallas, där Texas Instruments huvudkontor ligger.

Micro:bit -modulen ska nu vara installerad i ditt Python-bibliotek. Öppna ett nytt Python program: [menu], Nytt dokument, Lägg till Phyton, Nytt… och ge programmet ett lämpligt namn. Tryck sedan på [meny]> Fler moduler för att se att BBC micro:bit är listat under TI-modulerna.

Del 1: Möte med utomjordingar

Naturligtvis, som med alla andra första program i ett nytt språk eller med en ny programmeringsmiljö så börjar vi med att visa ett meddelande. Vi ska skriva en text med hjälp av micro:bit-skärmen.

Starta ett nytt TI-Nspire-dokument och välj Lägg till Python> Nytt... för att starta ett nytt program (tomt program), med namnet 'greetings'. I Python Editor använder du [menu]> Fler moduler> BBC micro:bit för att lägga till ett importkommando i din kod:

from microbit import *

För att visa ett textmeddelande på micro:bit-skärmen skavi använda metoden: display.show (bild eller text).

En metod är en funktion som ligger inbakad i en modul, eller snarare något som kallas för ett objekt. Dessa nås med modulnamnet.funktionsnamnet().

Du finner denna metod under:

[menu]> Fler moduler> BBC micro:bit> Display> Methods

Metoden infogas som display.show (bild eller text), men (bild eller text) är bara en platshållare som måste ersättas med något. Inom parentes, ersätt bild eller text genom att skriva din meddelandesträng med citattecken:

”greetings, earthlings”.

När du kör det här programmet genom att trycka på [ctrl] [R] kommer du att se bokstäverna i ditt meddelande visas, en bokstav i taget, på displayen. De små bokstäverna 'e' visas två gånger men du kan inte skilja dem åt.

En annan, i detta fall bättre, metod för att visa meddelandet är:

display.scroll (" greetings, earthlings")

Detta kommando finns också under:

[menu]> Fler moduler> BBC micro: bit> Display> Metods

För att slutföra .scroll () -uttrycket kan du kopiera/klistra in strängen från .show-metoden.

Gör föregående .show()-rad till ett #kommentar. Placera markören på raden och tryck på [ctrl] [T] för att göra den till en kommentar – som alltså inte kommer att köras - och kör sedan programmet igen.

Du kan också helt enkelt ändra .show till .scroll genom att skriva direkt in i koden.

Metoden .scroll() får meddelandet att rulla (flytta) från höger till vänster som en banner över displayen vilket gör det lättare att läsa.

Du kan styra rullningens hastighet genom att lägga till parametern delay = tid i millisekunder. Exempelvis:

display.scroll ("greetings, earthlings", delay = 200)

Detta ger en fördröjning på 200 millisekunder (0,2 sekunder) mellan varje steg i skrollningen. Prova gärna med andra fördröjnings-värden.

Del 2: Hjärtslag

Tryck på [ctrl] [doc] för att infoga en ny sida och välj Lägg till Python> Nytt.... för att lägga till ett nytt Python -program i ditt dokument (vi valde att döpa den till 'hjartslag' eftersom man i denna implementation av Python inte kan använda å, ä eller ö i dokumentnamn).

I Python Editor, använd [menu]> Fler moduler> BBC micro:bit och välj importutsagan högst upp i listan:

Vi ska visa en hjärt-symbol i displayen. För att visa den på micro:bit -displayen, så ska vi använda metoden display.show() igen.Vi finner denna under [[menu]> Fler moduler> BBC micro:bit> Display> Methods

Inuti parentesen ersätter du platshållaren, värde, genom att välja:

Image.HEART från [menu]> Fler moduler> BBC micro: bit> Display> Images> Set 1> HEART

Kör programmet (tryck [ctrl] [R]) för att se hjärtat på den lilla 5 ggr. 5 -rutnätet på micro:bit-enheten. Hjärtat kommer att visas tills något annat program körts eller till du kopplar ut enheten.

Vi ska nu försöka få hjärtat att bulta. Gå tillbaka till programredigeraren på föregående sida och lägg till ytterligare en rad för att visa ett litet hjärta:

display.show (Image.HEART_SMALL)

Du kan hitta den här bilden under samma bildmapp dom den tidigare bilden: [menu]> Fler moduler> BBC micro: bit> Display> Images> Set 1> HEART_SMALL

Tips: du kan också kopiera och klistra in den tidigare raden och sedan lägga till _SMALL till HEART. Du lägger till ett understrykningstecken och så ordet SMALL med stora bokstäver.

Om du kör programmet så kommer det stora hjärtat visas ett kort ögonblick varefter ett litet hjärta visas. Om du kör programmet ytterligare en gång hinner du nog se det stora hjärtat.

Ett hjärtslag verkar lite för lite. För att få hjärtat att blinka upprepade gånger så behöver vi lägga in de två show-radera i en loop. På raden Innan de två show-raderna ska vi lägga till ett while-kommando:

while get_key() != “esc”:

som vi hittar under [menu]> Fler moduler> BBC micro:bit> Commands

OBS: Se till att göra korrekt indrag på de två show-raderna så att de bildar det block av kod som ska loopas.

Kör ditt program igen för att se det bultande hjärtat. Du kan trycka på [esc] -knappen för att avsluta programmet. Det var det som var poängen med get_key() != “esc”:-raden.

Tips: om du någonsin tror att ditt program har fastnat i en oändlig loop, tryck in och håll ner [home/on] -knappen på din TI-Nspire för att avsluta programmet. Detta kan hända om du tillexempel använder while True: från kommandomenyn felaktigt. I dessa lektioner undviker vi den typen av strukturer.

Under micro:bit Commands finns några användbara Python-kommandon som också finns på andra menyer. Micro:bit -modulen importerar dessa Python-kommandon åt dig.

Du kan också finna dessa och andra kommandon under andra menyer. Du är inte begränsad till att bara använda BBC micro:bit -menyn när du programmerar micro:bit,  men du kan behöva lägga till rätt importkommandon.

Du finner detta kommando under [menu]> Fler moduler> BBC micro: bit> Commands.

För att kontrollera pulsslagens takt så kan du lägga till ett sleep- kommando efter varje displayvisningsrad. delay(1000) betyder 1000 millisekunders fördröjning, alltså en fördröjning på ensekund.

Tips: Tänk på indragen!

Extra: Prova att ”göra ansikten”. Använd en liknande programstruktur som i "hjärtslag " men använd de ansiktsbilder som finns i bildmapp 1 istället.

I den här lektionen lär du dig att använda micro:bits knappar och rörelsesensor. Vi ska skapa ett program som simulerar tärningskast och sedan spara resultatet i en lista som det kan exporteras till, och visas med TI-Nspires dataplot. Denna lektion består av två delar:

• Del 1: Utforska knapparnas funktion och effekten av rörelser
• Del 2: Använda rörelse och knappar för att generera data

Mål:

• Att läsa in om knapp A eller B trycks in.
• Veta skillnaden mellan .was och .is
• Att utbyta data mellan Python och TI-Nspire CX
• Att hantera data från micro:bit
• Att använda micro:bit-gester

Micro:bit-enheten har två knappar, märkta A och B, på vardera sidan av displayen.

Python micro:bit-modulen har metoder för att läsa knapparnas läge och sedan utföra uppgifter beroende på resultatet.

Först ska vi testa dessa metoder och sedan skriva ett Python-program som samlar in och analyserar data med TI-Nspire CX.

Det finns också en accelerometer/kompass-chip på baksidan av micro:bit-enheten, och metoder (kommandon) för att mäta enhetens rörelse och orientering med hjälp av dessa.

Del 1: Använda knappar och rörelser

Starta ett nytt Python-program i ett nytt dokument.

(Tryck på [Home]-knappen, välj Nytt och sedan Lägg till Python> Nytt...).

Ge den ett namn till exempel "knappar".

Börja igen med från microbit import * som du hittar under [menu]> Fler moduler> BBC micro:bit.

Vi börjar med att lägga till samma while-loop som tidigare med [menu]> Fler moduler> BBC micro:bit> Commands.

Nästan alla exempel med micro:bit har denna struktur.

För att testa om knapp A har tryckts in använder vi if -strukturen:

if button_a.was_pressed():

♢print("knapp A ")

If -satsen ska vara inne i while-loopen och vi måste därför lägga till rätt indrag. Utskriftskommandot är extra indraget, eftersom det tillhör if -satsen.

if-satsen finns under [menu]> Inbyggda> Kontroller

och button_a_was_pressed () finns under:

Vi ska nu testa om detta fungerar. Tryck på [ctrl] [R] för att köra programmet.

Först ser det ut som inget händer, men varje gång du trycker på knapp A visas texten “knapp A” på TI-Nspires skärm.

Tryck på [esc] för att stoppa programmet.

Lägg nu till en andra if-sats för knapp B men använd nu kommandot: if button_b.is_pressed ()

Observera att det nu står ".is" istället för ".was".

Återigen, var uppmärksam på att ha korrekta indragningarna.

Kör programmet igen och prova att trycka på knapparna A och B.

Skillnaden är att texten ”knapp A” inte skrivs ut förrän knappen släpps (was=var), medan ”knapp B” skrivs ut om och om igen så länge den hålls intryckt (is=är).

Observera att om du trycker in och snabbt släpper knappen B, kan det hända att det inte sker något eftersom knappen inte tryckts in just då när motsvarande if -sats kördes.

Rörelsedetektering (gester).

Micro:bit-enheten har en inbyggd accelerometer som kan mäta accelerationer i tre olika riktningar 90 grader mot varandra (det är en 3D accelerometer).

Förutom numeriska värden för accelerationen i varje riktning (se figuren) så har micro:bit också tydliga så kallade “gester” som "uppåt" och "med framsidan nedåt" baserat på dessa numeriska värden.

Vi kommer att undersöka detta med ett program.

Kommandot g = accelerometer.current_gesture() lagrar en sträng som visar vilken gest vi har gjort i variabeln g.

Du hittar det här kommandot under:

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

Skriv sedan ut värdet av g till konsolen med print(g).

Se till att du använder rätt indrag av texten. De två sista raderna ska höra till while-satsen, inte if-satsen.

Både knappar och gester låter dig hämta inmatning från micro:bit.

I nästa avsnitt ska vi samla in data med hjälp av micro:bit och sedan bearbeta det med TI-Nspire CX.

Del 2: Kasta en tärning

När knappen A trycks in ska en variabel ge ett slumpmässigt heltal från 1 till 6. Detta simulerar tärningskastet.

(I stället för knapp A kan du också använda knapp B eller en av gesterna.)

Skriv ut talet på micro:bit -skärmen.

Innan du fortsätter, kan du först försöka att skriva programmet själv.

Starta ett nytt Python -program och lägg till micro:bit -modulen igen.

För att kunna välja ett slumpmässigt nummer behöver vi en funktion från slumpmodulen. Vi lägger också till denna (se andra raden i programmet).

Vi ska lägga till samma while-sats som tidigare och behöver då en if-sats för att test om knapp A är intryckt. Sedan lägger vi till raden utfall = randint(1,6) som nu ger variabeln 'utfall' ett slumpmässigt värde (1 till 6) varje gång knappen A trycks in. (Tänk på indrag.)

Lägg nu till en radför att visa detta värde på micro:bit-enhetens display.

Detta görs med display.show (utfall).

Kör programmet. Varje gång du trycker på knapp A visas resultatet i micro:bit-displayen.

Datainsamling: Att kasta tärning genom att trycka på en knapp må vara kul, men vi vill spara resultaten så att vi kan dra slutsatser av dem.

Börja med att lägga till en tom lista där resultat ska lagras, i detta program kallas listan “resultat”.

Varje gång knappen A trycks in ska utfallet läggas till i resultat-listan. Du kan göra det med resultat.append().

Du hittar detta under [meny]> Inbyggda > Listor.

I slutet av programmet ska vi spara elementen i listan till en TI-Nspire-lista med kommandot:

store_list ("ögon", resultat).

Du hittar den här funktionen under:

[meny]> BBC micro:bit>  Commands

I den här lektionen kommer du att mäta ljusintensiteten med ljussensorn och spara data i en TI-Nspire-lista för vidare analys.

Mål:

• Att läsa av ljussensorn
• Att visa ljusstyrkan på displayen
• Att utbyta data mellan Python och TI-Nspire CX
• Att analysera data

Micro:bit-enheten kan mäta intensiteten av omgivande ljus med hjälp av displayens lysdioder.

Dessa lysdioder kan därför också användas som inmatningsenhet.  (Sök gärna på “leds as light sensors”)

Starta ett nytt Python -program i ett nytt dokument.

(Tryck på [Home] -knappen, välj Nytt och sedan Lägg till Python> Nytt...).

Ge den ett namn, till exempel "ljusstyrka". Lägg sedan till:

from microbit import *

display.clear()

while get_key() != "esc":

    ljus = display.read_light_level()

    print("Ljusstyrka =",ljus)

Metoden display.read_light_level() kan hittas med:

[menu]> Fler moduler> BBC micro: bit> Sensorer

Metoden display.clear() som du hittar under [menu]> Fler moduler> BBC micro: bit>Display>Methods släcker alla lysdioder i displayen.

Kör programmet och rikta mikro:bit-skärmen mot en ljuskälla. Du kommer då att se ljusstyrkan på din grafräknare.

Om du till exempel lägger handen över displayen kommer värdet att minska.

Tryck på [esc] för att stoppa programmet.

Tips: Blixen på en mobiltelefon går ofta att använda som en lampa.

Skapa två tomma listor före while -satsen:

tid = []

ljusstyrka = []

Vi låter t vara en variabel för tiden:

t = 0

I den första listan ska vi lagra vid vilka tidpunkter mätningarna gjordes. I den andra listan ska vi lagra uppmätta värden.

Infoga en sats som ökar t med 1 inne i while -slingan.

Lägg också till två kommandon för att lägga till t och ljusstyrka i listorna:

t = t+1

tid.append(t)

ljusstyrka.append(ljus)

Metoden .append finns under  [menu]> Inbyggda> Listor

Tiden mellan mätningar är lite godtycklig. Vi ska fixa det genom att göra en mätning varje sekund. Du kan göra detta genom att lägga till ett sleep-kommando i slutet av while-loopen.

sleep(1000) skapar en paus på en sekund.

Du hittar det här kommandot under

[menu]>BBC micro:bit>Commands

När vi stoppar mätningarna med [esc] så ska visparaPython-listorna i två TI-Nspire-listor med samma respektive namn.

Du kan använda kommandot store_list() för detta.

Observera att dessa två kommandon inte är indragna eftersom de inte ska köras varje gång. Först när loopen är avslutad måste listorna sparas.

store_list() kan hittas under:

[menu]>BBC micro:bit>Commands

Kör programmet och börja med micro:bit-enheten nära en ljuskälla. Flytta sedan långsamt enheten lite längre och längre bort från ljuskällan tills ljusstyrkan är 0.

När du har tillräckligt med mätningar trycker du på [esc] för att stoppa programmet. Lägg sedan till en extra sida i ditt dokument med [ctrl]-[doc] och välj Data & statistik.

Du kommer då att se en skärm som liknar den till höger

Klicka längst ned på skärmen för att välja en variabel och välj "tid" som en oberoende variabel.

Klicka sedan på vänster sida av skärmen och välj "ljusstyrka" som den beroende variabeln.

Punkterna bildar sedan en graf som förhoppningsvis någorlunda liknar den som visas här bredvid. Den exakta formen beror på hur du flyttade ljuskällan och micro:bit-enheten från varandra.

Tips: Om du kör experimentet igen kan du få fönstret att passa inläst data genom attt välja [menu]>Window/Zoom>Zoom Data

I denna applikation kan du använda ett program för att samla in data med hjälp av micro:bit.och sedan köra programmet i en delad skärm så att du kan se grafiken när du samlar in data.

Mål:

• Att skriva ett program.
• Att skapa ett dynamiskt diagram med sidan Data och Statistik.

I denna applikation använder du teknikerna från de tre lektionerna i denna enhet:

Samla in data med micro:bit med gester eller knappar och använda listor för att lagra och utbyta data med TI-Nspire CX.

Skapa sedan en TI-Nspire-sida där:

-  å ena sidan körs Python -programmet

- å andra sidan visas grafen (punktdiagram eller histogram) medan programmet körs.

Skapa ett nytt program och i det börja med att importera micro:bit -modulen och även den slumpmodulen.

Definiera sedan en tom lista (“ogon”) och spara den direkt som en TI-Nspire-lista och att listan också är tom när programmet startas.

Låt sedan programmet skriva ut instruktionen för användaren. I det här fallet ska vi använda alternativet att skaka micro:bit-enheten för att “kasta tärningarna”.

Programmet bör göra följande varje gång ett "kast" görs:

- skapa två slumpmässiga heltal (från 1 till 6)

- addera dem

- lägg till resultatet i listan "ogon"

- skriv ut antalet kast, de två utfallen och deras summa på skärmen

- visa också de två utfallen på micro:bit-displayen, en efter en

- lagra ogon till en TI-Nspire-lista.

Tips: Antalet kast är lika med listans längd: len(ogon)

Lägg till den sedvanliga while-loopen.

Lägg till en if-sats som testar om enheten har skakats. Om så är fallet skapa de två slumptalen.

Lägg ihop resultaten och lägg denna summa i listan ”ogon”.

Visa de två utfallen på micro:bit-displayen, en efter en med en liten paus emellan.

Metoden display.clear() används för att rensa föregående resultat från displayen så att det är klart att ett nytt värde visas igen.

Lägg till kod för att skriva ut informationen på TI-Nspire-skärmen och för att uppdatera TI-Nspire-listan.

Kör programmet och kasta tärningarna ungefär 50 gånger. Tryck på [esc] för att stoppa programmet.

Om Python-programmet går att köra utan fel, så fortsätt att länka inmatad data  till TI-Nspires statistikplottning.

Se till att du är i konsolen (sidan med >>> markören) och tryck sedan på [ctrl]-[doc] eller [ctrl]-[i] för att lägga till en sida, och välj Data & Statistik.

Förhoppningsvis ser du nu en skärm som den till höger.

Klicka på ”Klicka för att lägga till variabel” längst ned på skärmen, och välj ögon. Du kommer då att se ett punktdiagram över de data som har samlats in.

Gå tillbaka en sida till konsolen med

 [ctrl]-[vänsterpil] och tryck på [ctrl]-[4] för att slå ihop de två sidorna till en delad sida.

Till vänster i fönstret visas konsolen, och till höger applikationen Data & Statistik. 

Gå tillbaka till Python-redigeraren och starta om programmet med [ctrl]-[R]. Variablerna nollställs nu.

Du kommer sedan tillbaka till den delade skärmen och om du nu skakar micro:bit-enheten fram och tillbaka ser du en ny graf dyka upp.

Du kan också starta programmet från Python-konsolen (den vänstra delen av skärmen) genom att trycka [ctrl]-[R] när konsolen är vald.