Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen der Seite angezeigt.

--- gf_informatik:microbit_sca [2023-06-22 20:14] – [Aufgabe C2] sca
+++ gf_informatik:microbit_sca [2026-01-05 14:36] (aktuell) – sca
@@ Zeile 4: / Zeile 4: @@
 **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**.
+   * Link zu **Online-Editor**: https://python.microbit.org/
-   * Die Verwendung des Mu-Editors ist nicht gestattet (da er keinen Simulator besitzt).
+   * Verwende den Chrome Browser (oder Edge)
-   * Da wir im Online-Editor arbeiten, ist das **Speichern** etwas mühsam:
+   * Der Editor beinhaltet auch einen **Simulator**!
-     * Wir müssen die Codes von Hand in ein File auf dem Computer kopieren.
+   * Tipp zum **Speichern:**
-     * Verwende dazu die folgende Vorlage: {{ :gf_informatik:mikktrl_rob_aufgaben_template.docx |Template Aufgaben}}
+     * Lege auf OneNote eine Seite an, z.B. "MicroBit - Aufgaben"
-     * Bonus bei diesem Vorgehen: schöne Übersicht von allen deinen Codes!
+     * Copy-Paste deine Codes dort hineine
 **Bemerkungen:**
@@ Zeile 16: / Zeile 16: @@
      * [[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) =====
@@ Zeile 145: / Zeile 144: @@
 === Aufgabe C5 ===
-Folgende Code-Zeilen erstellen eine Liste aus 10 Bildern unterschiedlicher Helligkeit:
-<code python>
-my_images = []
-for i in range(0, 10, 1):
+Die LEDs sollen anzeigen, wie fest der Microbit geschüttelt wird:
-    my_img = Image()
-    my_img.fill(i)
+   * nicht geschüttelt: alle LEDs off
-    my_images.append(my_img)
+   * ganz stark geschüttelt: alle LEDs mit Stärke 9
+   * dazwischen: Alle LEDs mit Werten 1-8, je nachdem, wie stark geschüttelt
+Tipps:
+   * Verwende folgende Liste für die Anzeige:<WRAP><code python>
+all_leds = [
+    Image("00000:00000:00000:00000:00000"),
+    Image("11111:11111:11111:11111:11111"),
+    Image("22222:22222:22222:22222:22222"),
+    Image("33333:33333:33333:33333:33333"),
+    Image("44444:44444:44444:44444:44444"),
+    Image("55555:55555:55555:55555:55555"),
+    Image("66666:66666:66666:66666:66666"),
+    Image("77777:77777:77777:77777:77777"),
+    Image("88888:88888:88888:88888:88888"),
+    Image("99999:99999:99999:99999:99999"),
+]
+</code></WRAP>
+===== - 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>
-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 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.
-=== 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:
+===== - Aufgaben E (Radio) =====
-  * 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.
+**Relevante Theorie:**
-  * 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.
+   * [[gf_informatik:microbit_programmieren_grundlagen#radio|Theorie Radio]]
+=== Aufgabe E1 ===
+. Schreibe ein Programm zum Nachrichtenaustausch: Mit beiden Tasten und dem Touch-Logo sollen drei verschiedene Nachrichten versendet werden können: "yes", "no" und "maybe".
+. Weiter soll der Micro:Bit diese drei Nachrichten empfangen und anzeigen können: Wird 'yes' empfangen, wird ein "Y" angezeigt usw.
+. 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>
+<nodisp 1>
 ++++Lösungen Aufgaben A|
@@ Zeile 437: / Zeile 581: @@
 </code>
-=== C5 – Variante A ===
+=== C5 ===
+Variante 1
 <code python>
 from microbit import *
-my_images = []
+all_leds = [
+    Image("00000:00000:00000:00000:00000"),
-for i in range(0, 9, 1):
+    Image("11111:11111:11111:11111:11111"),
-    my_img = Image()
+    Image("22222:22222:22222:22222:22222"),
-    my_img.fill(i)
+    Image("33333:33333:33333:33333:33333"),
-    my_images.append(my_img)
+    Image("44444:44444:44444:44444:44444"),
+    Image("55555:55555:55555:55555:55555"),
-my_pos = 0
+    Image("66666:66666:66666:66666:66666"),
+    Image("77777:77777:77777:77777:77777"),
+    Image("88888:88888:88888:88888:88888"),
+    Image("99999:99999:99999:99999:99999"),
+]
 while True:
-    sleep(200)
+    # Variante 1
-    if my_pos < len(my_images) - 1:
+    ax,ay,az = accelerometer.get_values()
-        my_pos += 1
+    # Variante 2
+    ax = accelerometer.get_x()
+    ay = accelerometer.get_y()
+    az = accelerometer.get_z()
+    # Gesamtbeschleunigung
+    a = (ax*ax + ay**2 + az**2)**0.5
+    if a < 1200:
+        display.show(all_leds[0])
+    elif a <= 1500:
+        display.show(all_leds[1])
+    elif a <= 1800:
+        display.show(all_leds[2])
+    elif a <= 2100:
+        display.show(all_leds[3])
+    elif a <= 2400:
+        display.show(all_leds[4])
+    elif a <= 2700:
+        display.show(all_leds[5])
+    elif a <= 3000:
+        display.show(all_leds[6])
+    elif a <= 3300:
+        display.show(all_leds[7])
+    elif a <= 3600:
+        display.show(all_leds[8])
     else:
-        my_pos = 0
+        display.show(all_leds[9])
-    display.show(my_images[my_pos])
+    print(a)
+    sleep(400)
 </code>
-=== C5 – Variante B ===
+Variante 2 (elegant)
 <code python>
+# Imports go at the top
 from microbit import *
+import math
 my_images = []
-for i in range(0, 9, 1):
+all_leds = [
-    my_img = Image()
+    Image("00000:00000:00000:00000:00000"),
-    my_img.fill(i)
+    Image("11111:11111:11111:11111:11111"),
-    my_images.append(my_img)
+    Image("22222:22222:22222:22222:22222"),
+    Image("33333:33333:33333:33333:33333"),
+    Image("44444:44444:44444:44444:44444"),
+    Image("55555:55555:55555:55555:55555"),
+    Image("66666:66666:66666:66666:66666"),
+    Image("77777:77777:77777:77777:77777"),
+    Image("88888:88888:88888:88888:88888"),
+    Image("99999:99999:99999:99999:99999"),
+]
-display.show(my_images, delay = 200, loop = True)
+while True:
+    x,y,z = accelerometer.get_values()
+    a = math.sqrt(x*x+y*y+z*z)
+    strength = int((a - 1000) // 250)
+    if strength > 9:
+        strength = 9
+    elif strength < 0:
+        strength = 0
+    print(strength)
+    display.show(all_leds[strength])
+    sleep(200)
 </code>
-=== C6 ===
+++++
+</nodisp>
+<nodisp 2>
+++++Lösungen Aufgaben D|
+=== D1 ===
 <code python>
-from microbit import *
+from microbit import*
+import music
-my_images = []
+# Frère Jacques:
-my_pos = 0
+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
-for i in range(0, 9, 1):
+# Frère Jacques:
-    my_img = Image()
+melody_jacques = ['c4:4', 'd4:4', 'e4:4', 'c4:4','c4:4', 'd4:4', 'e4:4', 'c4:4',
-    my_img.fill(i)
+                 'e4:4', 'f4:4', 'g4:8', 'e4:4', 'f4:4', 'g4:8',
-    my_images.append(my_img)
+                 '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()):
-        sleep(100)
+        display.show(Image.HAPPY)
-        if my_pos < len(my_images) - 1:
+        music.play(melody_jacques[note])
-            my_pos += 1
+        sleep(30)
+        if(note < len(melody_jacques)-1):
+            note += 1
         else:
-            my_pos = 0
+            note = 0
-    display.show(my_images[my_pos])
+    else:
+        display.show(Image.ARROW_W)
 </code>
-=== C7 ===
+=== 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
-my_images = []
+while True:
-my_pos = 0
+    for freq in range(330, 770, 10):
+        music.pitch(freq, 100)
+    for freq in range(770, 330, -10):
+        music.pitch(freq, 100)
+</code>
-for i in range(0, 10, 1):
+=== D5 ===
-    my_img = Image()
+<code python>
-    my_img.fill(i)
+from microbit import *
-    my_images.append(my_img)
+import music
+freq = 440  # A4
 while True:
-    xAcceleration = accelerometer.get_x()
+    if button_a.is_pressed():
-    # xAcceleration von +/-2040 nach 0...9 umrechnen:
+        if freq < 4000:
-    my_pos = abs(xAcceleration) // 205
+            freq += 100
-    print(my_pos)
+        music.pitch(freq, 50)
-    display.show(my_images[my_pos])
+    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>