====== Micro:Bit Aufgaben ======

===== Informationen =====

**Editor:**
   * Wir arbeiten ausschliesslich mit dem [[https://python.microbit.org/v/3|Online-Editor]]. Achtung: funktioniert *nicht* in allen Browsern. Sicher funktioniert er in **Chrome**.
   * Die Verwendung des Mu-Editors ist nicht gestattet (da er keinen Simulator besitzt).
   * Da wir im Online-Editor arbeiten, ist das **Speichern** etwas mühsam:
     * Wir müssen die Codes von Hand in ein File auf dem Computer kopieren.
     * Verwende dazu die folgende Vorlage: {{ :gf_informatik:mikktrl_rob_aufgaben_template.docx |Template Aufgaben}}
     * Bonus bei diesem Vorgehen: schöne Übersicht von allen deinen Codes! 

**Bemerkungen:**
   * *Achtung:*  Diese Thema ist ein bisschen anders organisiert als die bisherigen Themen, da hier die Theorie und Aufgaben strikt getrennt werden:
     * [[gf_informatik:microbit_programmieren_grundlagen|Theoriedossier]]
     * [[gf_informatik:microbit_sca|Aufgaben]]
   * Für gewisse Aufgaben gibt es **zwei Versionen: Basic und Advanced**. Hier hast du die Wahl. Falls dir das Programmieren gut läuft, solltest du die Advanced-Aufgaben lösen. Für TALITs (und solche, die es sein sollten) sind die Advanced-Aufgaben Pflicht.
   * Adapter für USB C <-> A müssen selbst mitgebracht werden.

===== - Aufgaben A (Display) =====

**Relevante Theorie:**
   * [[gf_informatik:microbit_programmieren_grundlagen#display|Microbit: Display]]


=== Aufgabe A1 === 
Schreibe ein Programm, das eine Ente auf dem Display zeigt.

=== Aufgabe A2 === 
Schreibe ein Programm, das eine Animation aus fünf Bildern deiner Wahl zeigt. Jedes Bild soll eine Sekunde lang angezeigt werden.

++++Tipps|
Erstelle eine **Liste mit Bildern**: `my_images = [...]`.

Für die **Anzeige** gibt es mehrere Möglichkeiten, zum Beispiel:
   * Möglichkeit 1: Die Liste kann direkt der Funktion `display.show(...)` übergeben werden
   * Möglichkeit 2: Gehe in einer for-Schleife die Liste durch und zeige die Bilder an. Damit der ganze Vorgang beliebig oft wiederholt wird, packst du die ganze for-Schleife in eine `while True:`-Schleife.
   * Möglichkeit 3: Möchte man nur eine Schleife haben, kann man auch mit einem counter arbeiten, der die Bilder durchzählt. Achtung: Dieser muss dann rechtzeitig zurückgesetzt werden.
++++

=== Aufgabe A3 ===

== Basic ==

Das Display soll eine Animation zeigen, bei der das gesamte Display anfangs nur schwach, dann immer heller leuchtet. Erstelle dazu eine Liste aus *selbst erstellten Bildern*. Verwende dazu die `Image(...)` Funktion. Recherchiere selbst dazu, wie man diese verwendet.

== Advanced ==

   * Ähnlich wie 'Basic'. Das Display soll aber regelmässig pulsieren (heller werden, dann wieder dunkler, wieder heller, ...). Verwende keine Liste, sondern schreibe eine Funktion, die dir das passende Image erstellt.
   * Mit den beiden Tasten soll nun die Pulsgeschwindigkeit (in einer vorgegebenen Range) eingestellt werden können.

++++Tipps|

**Basic**

Ähnlich wie A2, nur werden die Bilder selbst definiert, z.B.
<code python>
all_1 = Image("11111:"
              "11111:"
              "11111:"
              "11111:"
              "11111")
</code>
Je grösser die Zahlen im String (0-9) desto heller leuchtet das Pixel. Übrigens kann man ein Bild auch auf einer Zeile definieren:
<code python>
all_1 = Image("11111:11111:11111:11111:11111")
</code>

**Advanced**

Man kann zuerst den String festlegen und erst nachher das Bild erzeugen:
<code python>
s = '00000:00000:00000:00000:00000'
img = Image(s)
</code>
Um ein helleres Bild zu erzeugen, muss man einfach alle Nullen im String mit einer anderen Zahl ersetzen (//replace//).

++++

=== Aufgabe A4 (Zusatzaufgabe: Advanced) ===

Mit ''set\_pixel()'' und ''get\_pixel()'' kannst du einzelne Pixel direkt ansteuern (siehe [[https://microbit-micropython.readthedocs.io/en/latest/display.html|Hier findest du alle Funktionen, mit denen du das Display ansteuern kannst.]])

Ein einzelnes Pixel soll nun die ganze LED-Matrix ablaufen: oberste Zeile von links nach rechts, dann zweite Zeile von links nach rechts ...




===== - Aufgaben B (Tasten) =====

**Relevante Theorie:**
   * [[gf_informatik:microbit_programmieren_grundlagen#tasten|Microbit: Tasten]]

=== Aufgabe B1 ===

Drückt man die linke Taste, wird ein Herz (oder irgend ein anderes Bild) angezeigt. Drückt man die rechte Taste, so erlöscht das Bild.

=== Aufgabe B2 ===

**Würfeln:** Programmiere einen digitalen Würfel. Drückt man eine der beiden Tasten, so wird eine Zufallszahl (1-6) bestimmt und das entsprechende Würfelbild angezeigt.

Tipps:
   * Definiere zuerst Bilder für die sechs Seiten des Würfels.
   * Verwende das ''random''-Modul, um eine random Zahl (resp. random Bild) zu bestimmen.

{{ :gf_informatik:wuerfel.jpg?100 |}}

**Spiele** mit einer Kolleg:in (die den Würfel auch bereits korrekt programmiert hat) das Leiterspiel. Spiele maximal 5 Minuten. Klicke auf das Bild, damit es gross angezeigt wird.

{{ :gf_informatik:leiterspiel.jpg?200 |}}

=== Aufgabe B3 ===

**Fotostrecke:** Befülle eine Liste mit einigen Bildern. Mit der linken und rechten Taste soll man die Bilder durchgehen können. Ist man am Ende der Liste angelangt, passiert nichts, wenn man weiter drückt.

Ist es hier besser, `is_pressed()` or `get_presses()` zu verwenden? Warum?

=== Aufgabe B4 (Zusatzaufgabe, mittel) ===

Zwei Spielerinnen würfeln abwechslungsweise (eine mit linkem, eine mit rechtem Knopf). Es wird immer die jeweils gewürfelte Zahl angezeigt. Im Hintergrund werden für beide Spielerinnen diese Werte aufsummiert. Wer zuerst die Summe 42 (oder mehr) erreicht hat, hat gewonnen. Von dieser Spielerin wird dann das Lieblingstier angezeigt.


===== - Aufgaben C (Beschleunigungssensor) =====

**Relevante Theorie:**

   * [[gf_informatik:microbit_programmieren_grundlagen#beschleunigungssensor|Theorie Beschleunigungssensor]]

=== Aufgabe C1 ===
Schreibe ein Programm, dass eine Ente anzeigt, wenn du den Microbit schüttelst und ein Haus, wenn du ihn nach oben drehst. 

=== Aufgabe C2 ===
Probiere den Code für den //Magic8Ball// unter im [[https://microbit-micropython.readthedocs.io/en/latest/tutorials/gestures.html#|Link hier]] aus:
  * Versuche zuerst, den Code zu verstehen. Kopiere ihn dann in deinen Editor und speichere das Programm. 
  * Lade das Programm auf den Microbit – jetzt kann dein Microbit in die Zukunft sehen:
  * Stelle ihm eine ja/nein-Frage zu deiner Zukunft und schüttle den Microbit – er wird dir eine hilfreiche Antwort anzeigen!

=== Aufgabe C3 ===
Schreibe ein Würfel-Programm, das immer dann, wenn der Microbit geschüttelt wird, eine zufällige Zahl zwischen 1 und 6 anzeigt. Nach einer Sekunde soll das Display wieder dunkel werden. Benutze die Funktion ''randint()'' aus dem Modul ''random''.

=== Aufgabe C4 ===
Speichere das Programm aus Aufgabe **C3** unter neuem Namen und ändere es: 
  * Es soll immer dann eine neue Zahl angezeigt werden, wenn der Microbit nach oben gedreht wurde.
  * Das Display soll nur dann dunkel werden, wenn das Touch-Logo berührt wurde.

=== Aufgabe C5 ===
Folgende Code-Zeilen erstellen eine Liste aus 10 Bildern unterschiedlicher Helligkeit: 
<code python>
my_images = []

for i in range(0, 10, 1):
    my_img = Image()
    my_img.fill(i)
    my_images.append(my_img)
</code>
In der For-Schleife geschieht Folgendes für jeden Wert von i, also von 0 bis 9, also zehn mal:
  * Zuerst wird mit der Funktion ''Image()'' ein leeres Bild namens ''my\_img'' erstellt. 
  * Dieses Bild wird  nun gefüllt: Die Funktion ''fill()'' füllt jedes Pixel des Bildes mit einer bestimmten Helligkeit. Weil ''i'' bei jedem Durchlauf erhöht wird, wird ''my\_img'' bei jedem Durchlauf um eine Stufe heller – von 0 (dunkel) bis 9 (ganz hell)
  * Das Bild wird der Liste ''my\_images'' hinzugefügt.

Schreibe ein Programm, in das du obigen Code hinein kopierst, das die Bilder mit 200 Milliskeunden Verzögerung nacheinander endlos anzeigt. 

=== Aufgabe C6 ===
Speichere das Programm aus Aufgabe **C5** unter neuem Namen und ändere es: 
  * Immer dann, wenn du die Taste A drückst, soll das nächste Bild aus der Liste angezeigt werden. 
  * Nach dem letzten (hellsten) Bild, soll wieder das erste angezeigt werden.
  * Tipp: Damit du mit einem Tastendruck nicht gleich mehrere Bilder weiterspringst: baue eine Verzögerung mit ''sleep()'' ein.

=== Aufgabe C7 (Knacknuss) ===
Speichere das Programm aus Aufgabe **C6** unter neuem Namen und ändere es:
  * Das Display soll umso heller leuchten, je stärker du den Microbit hin und her schüttelst. 
  * Lese dazu den x-Wert aus dem Beschleunigungssensor aus.
  * Dieser liegt im Bereich von +/- 2040. Du brauchst aber einen Index-Wert von 0...9.
  * Tipps: Die Funktion ''abs()'' gibt den absoluten Wert, also den Betrag einer Zahl zurück. Der Operator ''%%//%%'' (//floor division//) dividiert und rundet das Resultat auf ganze Zahlen ab.

===== - Aufgaben D (Sounds) =====

**Relevante Theorie:**

   * [[gf_informatik:microbit_programmieren_grundlagen#sounds|Theorie Sounds]]


=== Aufgabe D1 ===
Schreibe ein Programm, dass die Melodie //Frère Jacques// spielt (mit Pause zwischen gleichen Tönen), **solange du die A-Taste gedrückt hältst**:
  * Sobald du die A-Taste loslässt, stoppt die Melodie. 
  * Sobald du die Taste wieder drückst, geht die Melodie dort weiter, wo sie zuletzt unterbrochen wurde.

=== Aufgabe D2 ===
Speichere dein Programm aus Aufgabe **D1** unter neuem Namen und erweitere es: 
  * Solange die A-Taste gedrückt ist, soll das Display ein Smiley-Face zeigen.
  * Solange die A-Taste nicht gedrückt ist, soll das Display einen Pfeil Richtung Taste A zeigen.
Jetzt kannst du versuchen, //Frère Jacques// mit andern im Kanon zu spielen.

=== Aufgabe D3 ===
Speichere dein Programm aus Aufgabe **D2** unter neuem Namen und erweitere es: 
  * Zusätzlich soll mit Taste B eine zweite Melodie gespielt werden, also: Solange Taste A gedrückt ist, wird Melodie A gespielt; solange Taste B gedrückt ist, wird Melodie B gespielt. 
  * Das Display soll bei jeder Melodie ein anderes Bild zeigen.
  * Wenn keine Taste gedrückt ist, soll das Display nichts zeigen.
  * Wähle eine Melodie, die dir gefällt: Noten findest du zum Beispiel, wenn du in der Bilder-Suche nach dem Lied-Titel und dem Stichwort "Noten" oder "notes" suchst. Achte darauf, dass die Melodie nicht zu lange dauert. [[https://www.lieder-archiv.de/lieder_sammlung_a.html|Hier ein Sammlung eher einfacher und kurzer Melodien]].

=== Aufgabe D4 ===
Schreibe ein Programm, das einen Alarm-Ton erzeugt:
  * Zuerst wird ein ansteigender Ton ausgegeben: zwischen 330 Hz und 770 Hz, in 10-Hz-Schritten erhöht.
  * Danach wird ein fallender Ton ausgegeben: zwischen 770 Hz und 330 Hz, in 10-Hz-Schritten verringert.
  * Jeder Einzelton soll 0.1 Sekunden lang gespielt werden. Von 330 Hz nach 770 Hz sind es 44 10-er-Schritte. Das hiesst, es soll 44 * 0.1 = 4.4 Sekunden dauern, bis die höchste Frequenz erreicht ist – und ebenso lang, bis wieder die tiefste erreicht ist.
  * Der Alarm-Ton wird endlos ausgegeben. 

=== Aufgabe D5 ===
Schreibe ein Programm, das einen Ton ausgibt, den du mit den Tasten einstellen kannst:
  * Wenn du die A-Taste drückst, wird die Frequenz des Tons erhöht.
  * Wenn du die B-Taste drückst, wird die Frequenz des Tons verringert.
  * Wenn keine Taste gedrückt ist, wird auch kein Ton ausgegeben. (Nur während des Tastendrucks soll ein Ton gespielt werden).
  * Die auszugebende Frequenz darf 100 Hz nicht unter- und 4000 Hz nicht überrschreiten – egal wie lange die jeweiligen Tasten gedrückt sind.

=== Aufgabe D6 ===
Schreibe ein Programm, das optisch und akustisch auf Bewegungen reagiert:
  * Wenn der Microbit nach oben gedreht wird, soll das Programm ein //Happy Face// zeigen und einen passenden Ton ausgeben.
  * Wenn der Microbit nach unten gedreht wird, soll das Programm ein //Sad Face// zeigen und einen passenden Ton ausgeben.
  * Wenn der Microbit nicht bewegt wird, bleibt er dunkel und still.

**Tipp:** Wenn du dir [[https://microbit-micropython.readthedocs.io/en/latest/music.html#built-in-melodies|vordefinierte Melodien]] kurz anhören möchtest, ohne jedes Mal ein neues Programm auf den Microbit zu laden, kannst du bei verbundenem Microbit im //Mu Editor// auf die Taste ''REPL'' drücken. Es erscheint ein Eingabefenster. Hier schreibst du Befehle //direkt auf den Microbit//: sobald du die Enter-Taste drückst, wird der Befehl ausgeführt: Zum Beispiel: ''music.play(music.BLUES)''. Probiere es aus!

{{:gf_informatik:screenshot_2021-07-06_at_17.42.34.png?600|}}

Übrigens: REPL steht für [[https://python-editor-2-2-1.microbit.org/help.html?snippets=true#REPL|Read-Evaluate-Print-Loop]]. Diese Funktion gibt es auch im Online-Editor über die Taste ''Open Serial''.

=== Aufgabe D7 (Herausforderung) ===
Schreibe ein Programm, das die Cancan-Melodie (siehe unten) in unterschiedlichen Tempi spielt:
  * Wenn die A-Taste gedrückt wird, soll das Tempo um 40 bpm erhöht werden. 
  * Wenn die B-Taste gedrückt wird, soll das Tempo um 40 bpm reduziert werden.
  * Mit dem Touch-Logo kann die Melodie gestartet und gestoppt werden:
    * Wenn das Touch-Logo berührt wird, erscheint für 200 ms ein //HAPPY Face// auf dem Display. Dann erlischt es wieder.
    * Ausserdem soll bei jeder Berührung des Touch-Logos eine Variable zwischen 0 und 1 wechseln ([[https://exceptionshub.com/how-to-toggle-a-value-in-python.html|toggeln]]).
    * Nur wenn diese Variable 1 ist, soll die Melodie gespielt werden, sonst nicht.
  * **Tipp:** Setze vor der Endlos-Schleife die Variable für das Tempo auf 320 und die Variable für das Starten/Stoppen der Melodie auf 0.

<code python>
#Cancan by Jacques Offenbach:
melodyCancan = ['c4:16', 
                'd4:4', 'f4:4', 'e4:4', 'd4:4', 'g4:8', 'g4:8',
                'g4:4', 'a4:4', 'e4:4', 'f4:4', 'd4:8', 'd4:8',
                'd4:4', 'f4:4', 'e4:4', 'd4:4', 
                'c4:4', 'c5:4', 'b4:4', 'a4:4',
                'g4:4', 'f4:4', 'e4:4', 'd4:4',
                'c4:16', 
                'd4:4', 'f4:4', 'e4:4', 'd4:4', 'g4:8', 'g4:8',
                'g4:4', 'a4:4', 'e4:4', 'f4:4', 'd4:8', 'd4:8',
                'd4:4', 'f4:4', 'e4:4', 'd4:4',
                'c4:4', 'g4:4', 'd4:4', 'e4:4', 
                'c4:8', 'c5:4', 'r:4']
</code>

=== Aufgabe D8 (Knacknuss) ===
Speichere dein Programm aus Aufgabe **D7** unter neuem Namen und erweitere es: Zusätzlich zum Tempo soll nun auch die Tonlage verändert werden:
  * Schreibe eine Funktion ''change_octave(step=1)''. Diese soll jede Note in der Liste ''melodyCancan'' um eine Oktave erhöhen oder verringern. Wird der Funktion die Zahl 1 übergeben, so wird jede Note um eine Oktave erhöht; wird der Funktion die Zahl -1 übergeben, so wird Note um eine Oktave verringert.
  * Mit der A-Taste soll neben dem Tempo auch die Tonlage erhöht werden.
  * Mit der B-Taste soll neben dem Tempo auch die Tonlage verringert werden.



===== - Aufgaben E (Radio) =====

**Relevante Theorie:**

   * [[gf_informatik:microbit_programmieren_grundlagen#radio|Theorie Radio]]

=== Aufgabe E1 ===

   1. Schreibe ein Programm zum Nachrichtenaustausch: Mit beiden Tasten und dem Touch-Logo sollen drei verschiedene Nachrichten versendet werden können: "yes", "no" und "maybe".
   1. Weiter soll der Micro:Bit diese drei Nachrichten empfangen und anzeigen können: Wird 'yes' empfangen, wird ein "Y" angezeigt usw.
   1. Einige dich mit deiner Kolleg:in auf eine eigene Gruppe oder Kanal, über den ihr kommunizieren wollt. Stellt euch nun mündliche Fragen und antwortet euch gegenseitig mit dem Micro:Bit.

=== Aufgabe E2 ===
Speichert das Programm aus Aufgabe **E1** unter neuem Namen und ändert es: Die Nachrichten sollen nun nicht mehr am Display angezeigt, sondern über das [[https://microbit-micropython.readthedocs.io/en/latest/tutorials/speech.html|Speech-Modul]] gesprochen werden. Das ist nun nicht mehr so geheim.

=== Aufgabe E3 ===
Schreibt ein Programm, mit dem das Display des anderen Microbit leuchtet, solange ihr die Taste des einen Microbit gedrückt hält. So könntet ihr Morsezeichen übermitteln. 
  * Wenn die A-Taste gedrückt wird, soll eine beliebige Nachricht gesendet werden.
  * Solange eine Nachricht empfangen wird, soll das gesamte Display hell leuchten. 
  * Solange keine Nachricht empfangen wird, soll das Display nicht leuchten.

{{:gf_informatik:morse.png?400|}}

=== Aufgabe E4 (Beacon 1) ===
Über BLE kann ein Microbit als **Beacon** (engl. für //Leuchtturm// oder //Blinklicht//) fungieren. Ein BLE-Beacon sendet regelmässig eine einfache Nachricht. Der Empfänger kann dann die Signalstärke dieser Nachricht messen: Je näher der Beacon, desto stärker das Signal. Auf diese Weise kannst du feststellen, ob ein bestimmter Beacon in der Nähe ist. 

Schreibt zwei Programme, eines für den Beacon (Sender) und eines für den Empfänger:

* Der Sender sendet alle 200 Millisekunden eine Nachricht. 
* Der Empfänger schaut ständig nach einkommenden Nachrichten und deren Signalstärke:
 * Mit der Anweisung ''message = radio.receive_full()'' werden in ''message'' mehrere Elemente gespeichert: die Nachricht selbst [0], die Signalstärke [1] und die genaue Ankunftszeit der Nachricht in Mikrosekunden [2]. Eine solche Variable, die mehrere Elemente speichert, wird //Tupel// (engl. //tuple//) genannt. Im Unterschied zu einer Liste, die ebenfalls mehrere Elemente enthält, kannst du bei der Tupel nicht einzelne Elemente ändern, nur auslesen.
 * Um die Signalstärke zu erhalten, brauchst du das zweite Element aus der Tupel, also: ''signal = message[1]''.
 * Das Programm soll nun die Signalstärke mit der Funktion ''print()'' an deinen Laptop senden.

Testet die beiden Programme und **notiert euch die Werte** für die grösste und die kleinste Entfernung zwischen Beacon und Empfänger. Die Werte könnt ihr ansehen, wenn ihr im Mu Editor die Taste ''Plotter'' und dann ''REPL'' drückt. Zum Testen des Programms könnt ihr einen Microbit in ein Maqueen-Fahrwerk stecken und ihn so ohne Kabel mit Strom versorgen.

Stellt sicher, dass alle von euch beide Programme verstehen!

=== Aufgabe E5 (Beacon 2) ===
Jetzt kennt ihr die Werte für das stärkste und für das schwächste Signal. Schreibt nun ein Programm für den Empfänger, das die Nähe de Beacons akkustisch angibt.

* Wenn keine Nachricht empfangen wird, bleibt der Microbit still.
* Wenn eine Nachricht empfangen wird, gibt der Microbit kurze (50 ms) Töne von sich, die immer schneller aufeinanderfolgen, je näher der Beacon ist:
 * bei der weitesten Entfernung soll der Intervall (Abstand zwischen den Tönen) ca. 700–800 ms betragen.
 * bei der kürzesten Entfernung soll der Intervall ca. 150-200 ms betragen.
 * Überlegt, wie ihr Signalstärke in Intervall umrechnet. Beachtet, dass die Signalstärke negativ ist.
* Das Programm für den Beacon könnt ihr wie folgt optimieren:
 * Die Signalstärke kann über ''radio.config(power=1)'' reduziert werden (standardmässig ist power auf 6). 
 * Eine LED des Display kann blinken, damit man sieht, dass der Beacon sendet.

=== Aufgabe E6 (Anonyme Umfragen) ===
Schreibt ein Programm, mit dem ihr anonyme Umfragen durchführen könnt. 

* Wenn die Taste A gedrückt wird, sendet der Microbit die Nachricht "Ja". 
* Wenn die Taste B gedrückt wird, sendet der Microbit die Nachricht "Nein".
* Verwende `get_presses()` und füge zur Sicherheit den Tasten eine Verzögerung mit ''sleep(300)'' hinzu, sodass bei jedem Tastendruck sicher nur //eine// Nachricht gesendet wird.
* Wann immer eine Nachricht empfangen wird, wird sie ausgewertet:
 * Ist der Inhalt der Nachricht "Ja", so wird eine Variable zum Zählen der Ja-Stimmen um 1 erhöht.
 * Ist der Inhalt der Nachricht "Nein", so wird eine Variable zum Zählen der Nein-Stimmen um 1 erhöht.
* Wenn das Touch-Logo berührt wird, soll das Display die Anzahl Ja- und die Anzahl Nein-Stimmen anzeigen.
* Testet euer Programm: Einigt euch zu viert auf dieselbe Gruppen-Nummer (oder Kanal-Nummer), stellt Fragen und antwortet über die A- und B-Tasten.

=== Aufgabe E7 (Knacknuss) ===
Das Programm aus Aufgabe E erlaubt, dass mehrere Nachrichten vom selben Microbit gezählt werden. Bei einer Abstimmung kann so das Resultat verfälscht werden. Ändere das Programm so, dass jeder Microbit pro Umfrage nur einmal abstimmen kann – entweder ja oder nein. Teste das Programm erst mit wenigen und dann mit der ganzen Klasse.

===== Lösungen =====

<nodisp 2>

++++Lösungen Aufgaben A|
=== A1 ===
<code python>
from microbit import *
display.show(Image.DUCK)
</code>

=== A2 ===
<code python>
from microbit import *

my_images = [Image.SAD, Image.MEH, Image.YES, Image.NO, Image.COW]

display.show(my_images, delay = 1000, loop = True)
</code>

oder

<code python>
from microbit import *
 
my_images = [Image.SAD, Image.MEH, Image.YES, Image.NO, Image.COW]

while True:
    for img in my_images:
        display.show(img)
        sleep(500)
</code>

oder

<code python>
from microbit import *
 
my_images = [Image.SAD, Image.MEH, Image.YES, Image.NO, Image.COW]

i = 0
while True:
    display.show(my_images[i])
    sleep(500)
    i = i + 1
    if i == len(my_images):
        i = 0
</code>

=== A3 ===

== Basic ==
<code python>
from microbit import *

all_1 = Image("11111:"
              "11111:"
              "11111:"
              "11111:"
              "11111")

all_3 = Image("33333:"
              "33333:"
              "33333:"
              "33333:"
              "33333")

all_5 = Image("55555:"
              "55555:"
              "55555:"
              "55555:"
              "55555")

all_7 = Image("77777:"
              "77777:"
              "77777:"
              "77777:"
              "77777")

all_9 = Image("99999:"
              "99999:"
              "99999:"
              "99999:"
              "99999")

my_images = [all_1, all_3, all_5, all_7, all_9]

display.show(my_images, delay = 100, loop = True)
</code>

== Advanced ==

<code python>
from microbit import *
 
def create_img(n):
    s = '00000:00000:00000:00000:00000'
    s = s.replace('0',str(n))
    return Image(s)
 
up = True
counter = 0
delay = 100
delay_min = 20
delay_max = 1000
delay_change = 10

while True:
    display.show(create_img(counter))
    sleep(delay)
 
    # change counter for next image
    if up: # going up
        if counter < 9:
            counter += 1
        else: # reverse direction
            counter = 8
            up = False # go down
    else: # going down
        if counter > 0:
            counter -= 1
        else: # reverse direction
            counter = 1
            up = True # go up

    # change delay if button pressed
    if button_a.is_pressed() and delay < delay_max:
        delay += delay_change
    if button_b.is_pressed() and delay > delay_min:
        delay -= delay_change  
</code>

=== A4 ===
<code python>
from microbit import *

counter = 0
while True:
    for brightness in range(1,9,2):
        sleep(20)
        display.clear()
        row = counter % 5 # get row number
        column = counter // 5 # get column number
        display.set_pixel(row,column,9)

    if counter < 24:
        counter += 1
    else:
        counter = 0
</code>
++++

</nodisp>

<nodisp 2>
++++Lösungen Aufgaben B|
=== B1 ===
<code python>
from microbit import *

while True:
    if button_a.is_pressed():
        display.show(Image.GHOST)
    if button_b.is_pressed():
        display.show(Image.RABBIT)
    if pin_logo.is_touched():
        display.clear()
</code>

=== B2 ===
<code python>
from microbit import *

while True:
    if button_a.is_pressed():
        display.scroll("Taste_A")
    if button_b.is_pressed():
        display.show(Image.RABBIT)
    if pin_logo.is_touched():
        display.clear()
</code>

=== B3 ===
<code python>
from microbit import *

while True:
    if button_a.is_pressed():
        display.scroll("Taste_A", wait=False)
    if button_b.is_pressed():
        display.show(Image.RABBIT)
    if pin_logo.is_touched():
        display.clear()
</code>

=== B4 ===
<code python>
from microbit import *

while True:
    if button_a.is_pressed():
        display.show(Image.HAPPY)
    elif button_b.is_pressed():
        display.show(Image.SAD)
    elif pin_logo.is_touched():
        display.show(Image.HEART)
    else:
        display.clear()
</code>

=== B5 ===
<code python>
from microbit import *

while True:
    if pin_logo.is_touched():
        display.scroll(str(button_a.get_presses()-button_b.get_presses()))
</code>
++++
</nodisp>


<nodisp 2>
++++Lösungen Aufgaben C|
=== C1 ===
<code python>
from microbit import *

while True:
    if accelerometer.was_gesture("shake"):
        display.show(Image.DUCK)
    elif accelerometer.was_gesture("face up"):
        display.show(Image.HOUSE)
</code>

=== C2 ===
[[https://microbit-micropython.readthedocs.io/en/latest/tutorials/gestures.html#magic-8|Siehe hier]]

=== C3 ===
<code python>
from microbit import *
import random

while True:
    if accelerometer.was_gesture("shake"):
        display.show(random.randint(1,6))
        sleep(1000)
        display.clear()
</code>

=== C4 ===
<code python>
from microbit import *
import random

while True:
    if accelerometer.was_gesture("face up"):
        display.show(random.randint(1,6))
        sleep(1000)
    if pin_logo.is_touched():
        display.clear()
</code>

=== C5 – Variante A ===
<code python>
from microbit import *

my_images = []

for i in range(0, 9, 1):
    my_img = Image()
    my_img.fill(i)
    my_images.append(my_img)

my_pos = 0

while True:
    sleep(200)
    if my_pos < len(my_images) - 1:
        my_pos += 1
    else:
        my_pos = 0
    display.show(my_images[my_pos])
</code>

=== C5 – Variante B ===
<code python>
from microbit import *

my_images = []

for i in range(0, 9, 1):
    my_img = Image()
    my_img.fill(i)
    my_images.append(my_img)

display.show(my_images, delay = 200, loop = True)
</code>

=== C6 ===
<code python>
from microbit import *

my_images = []
my_pos = 0

for i in range(0, 9, 1):
    my_img = Image()
    my_img.fill(i)
    my_images.append(my_img)

while True:
    if(button_a.is_pressed()):
        sleep(100)
        if my_pos < len(my_images) - 1:
            my_pos += 1
        else:
            my_pos = 0
    display.show(my_images[my_pos])
</code>

=== C7 ===
<code python>
from microbit import *

my_images = []
my_pos = 0

for i in range(0, 10, 1):
    my_img = Image()
    my_img.fill(i)
    my_images.append(my_img)

while True:
    xAcceleration = accelerometer.get_x()
    # xAcceleration von +/-2040 nach 0...9 umrechnen:
    my_pos = abs(xAcceleration) // 205
    print(my_pos)
    display.show(my_images[my_pos])
</code>
++++
</nodisp>

<nodisp 2>
++++Lösungen Aufgaben D|
=== D1 ===
<code python>
from microbit import*
import music

# Frère Jacques:
melody_jacques = ['c4:4', 'd4:4', 'e4:4', 'c4:4','c4:4', 'd4:4', 'e4:4', 'c4:4',
                 'e4:4', 'f4:4', 'g4:8', 'e4:4', 'f4:4', 'g4:8',
                 'g4:2', 'a4:2', 'g4:2', 'f4:2', 'e4:4', 'c4:4',
                 'g4:2', 'a4:2', 'g4:2', 'f4:2', 'e4:4', 'c4:4',
                 'c4:4', 'g3:4', 'c4:8', 'c4:4', 'g3:4', 'c4:8']

note = 0
while True:
    if(button_a.is_pressed()):
        music.play(melody_jacques[note])
        sleep(30)
        if(note < len(melody_jacques)-1):
            note += 1
        else:
            note = 0
</code>

=== D2 ===
<code python>
from microbit import*
import music

# Frère Jacques:
melody_jacques = ['c4:4', 'd4:4', 'e4:4', 'c4:4','c4:4', 'd4:4', 'e4:4', 'c4:4',
                 'e4:4', 'f4:4', 'g4:8', 'e4:4', 'f4:4', 'g4:8',
                 'g4:2', 'a4:2', 'g4:2', 'f4:2', 'e4:4', 'c4:4',
                 'g4:2', 'a4:2', 'g4:2', 'f4:2', 'e4:4', 'c4:4',
                 'c4:4', 'g3:4', 'c4:8', 'c4:4', 'g3:4', 'c4:8']

note = 0
while True:
    if(button_a.is_pressed()):
        display.show(Image.HAPPY)
        music.play(melody_jacques[note])
        sleep(30)
        if(note < len(melody_jacques)-1):
            note += 1
        else:
            note = 0
    else:
        display.show(Image.ARROW_W)
</code>

=== D3 ===
<code python>
from microbit import*
import music

# Frère Jacques:
melody_jacques = ['c4:4', 'd4:4', 'e4:4', 'c4:4','c4:4', 'd4:4', 'e4:4', 'c4:4',
                 'e4:4', 'f4:4', 'g4:8', 'e4:4', 'f4:4', 'g4:8',
                 'g4:2', 'a4:2', 'g4:2', 'f4:2', 'e4:4', 'c4:4',
                 'g4:2', 'a4:2', 'g4:2', 'f4:2', 'e4:4', 'c4:4',
                 'c4:4', 'g3:4', 'c4:8', 'c4:4', 'g3:4', 'c4:8']

# Popcorn:
melody_pop =     ['b4:2', 'a4:2', 'b4:2', 'f4:2','d4:2', 'f4:2', 'b3:4',
                 'b4:2', 'a4:2', 'b4:2', 'f4:2','d4:2', 'f4:2', 'b3:4',
                 'b4:2', 'c#5:2', 'd5:2', 'c#5:2', 'd5:2', 'b4:2', 'c#5:2', 'b4:2', 'c#5:2', 'a4:2',
                 'b4:2', 'a4:2', 'b4:2', 'g#4:2', 'b4:4','r:4']

noteA = 0
noteB = 0
while True:
    if(button_a.is_pressed()):
        music.set_tempo(bpm = 120) # Diese Melodie normal spielen
        display.show(Image.ASLEEP)
        music.play(melody_jacques[noteA])
        sleep(30)
        if(noteA < len(melody_jacques)-1):
            noteA += 1
        else:
            noteA = 0

    elif(button_b.is_pressed()):
        music.set_tempo(bpm = 200) # Diese Melodie schneller spielen
        display.show(Image.MUSIC_CROTCHET)
        music.play(melody_pop[noteB])
        sleep(30)
        if(noteB < len(melody_pop)-1):
            noteB += 1
        else:
            noteB = 0

    else:
        display.clear()
</code>

=== D4 ===
<code python>
from microbit import *
import music

while True:
    for freq in range(330, 770, 10):
        music.pitch(freq, 100)
    for freq in range(770, 330, -10):
        music.pitch(freq, 100)
</code>

=== D5 ===
<code python>
from microbit import *
import music

freq = 440  # A4
while True:
    if button_a.is_pressed():
        if freq < 4000:
            freq += 100
        music.pitch(freq, 50)
    if button_b.is_pressed():
        if freq > 100:
            freq -= 100
        music.pitch(freq, 50)
</code>

=== D6 ===
<code python>
from microbit import *
import music

while True:
    if accelerometer.was_gesture("face up"):
        display.show(Image.HAPPY)
        music.play(music.JUMP_UP)
    elif accelerometer.was_gesture("face down"):
        display.show(Image.SAD)
        music.play(music.JUMP_DOWN)
    else:
        display.clear()
</code>
++++
</nodisp>