Aufgaben Microbit [KSR Wiki]

Diese Seite ist nicht editierbar. Du kannst den Quelltext sehen, jedoch nicht verändern. Kontaktiere den Administrator, wenn du glaubst, dass hier ein Fehler vorliegt.
===== Aufgaben Microbit =====
Eine Übersicht über alle Funktionen und grundlegende Informationen findest du hier: [[..:microbit_programmieren_grundlagen|]]
 
Einige Aufgaben sind mit "Advanced" gekennzeichnet. Hast du keine Probleme mit den Aufgaben, solltest du die Advanced-Aufgaben lösen. Für TALITs sollte dies eigentlich der Standard sein.

==== Aufgaben A (Display) ====
Studiere erst den Abschnitt [[..:microbit_programmieren_grundlagen#display|Display]] im Microibt-Wiki. 
=== Aufgabe A1 – Ente=== 
Schreibe ein Programm, das eine Ente auf dem Display zeigt.

=== Aufgabe A2 – Fünf Bilder === 
Schreibe ein Programm, das eine Animation aus fünf Bildern deiner Wahl zeigt. Jedes Bild soll eine Sekunde lang angezeigt werden. Schaffst du es auch mit insgesamt nur drei Code-Zeilen?

++++Tipps|
Erstelle eine Liste mit Bildern: `my_images = [...]`. Für das Anzeigen gibt es mehrere Möglichkeiten, zum Beispiel:
  * Möglichkeit 1: 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 2: Die Liste kann direkt der Funktion `display.show(...)` übergeben werden
++++

=== Aufgabe A3 – Countdown === 
Schreibe ein Programm, das im Sekundentakt die Zahlen von 9 runter zählt (auf dem Display zeigt). Bei 0 soll das Display einen Schmetterling zeigen. Du brauchst hierzu **keine Liste**.

=== Aufgabe A4 – Immer heller ===

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.

++++Tipps:|
Ä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>
++++

=== Aufgabe A5 – Pulsieren (Advanced) ===
Siehe Aufgabe A4. 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.

++++Tipps:|
== Bild erstellen Variante A ==
Du kannst zuerst einen String festlegen und nachher das Bild erzeugen:
<code python>
s = '00000:00000:00000:00000:00000'
img = Image(s)
</code>
Um ein helleres Bild zu erzeugen, kannst du alle Nullen im String mit einer anderen Zahl ersetzen (//replace//):
<code python>
s = s.replace('0', str(7)) # Ersetzt alle Zeichen '0' in s durch das Zeichen '7'.
</code>

== Bild erstellen Variante B ==
Du kannst ein Bild erstellen und es dann mit der fill()-Funktion füllen.
<code python>
img =  Image('00000:00000:00000:00000:00000')
img.fill(7) # Füllt alle Pixel in img mit Helligkeit 7.
</code>

== Hoch- und runterzählen ==
  * Erstelle eine Variable, zum Beispiel namens ''counting\_up''. Diese speichert, ob gerade hoch- oder runtergezählt wird: Ist die Variable ''True'', so wird hochgezählt, ist sie ''False'', so wird runtergezählt. Setze die Variable anfangs auf ''True''. 
  * Erstelle auch eine Zählvariable, zum Beispiel namens ''counter''. Diese erhöhst du um 1, wenn ''counting\_up'' gleich ''True'' ist. Verringere sie um 1, wenn ''counting\_up'' gleich ''False'' ist.
  * Wann musst du ''counting\_up'' auf auf ''False'' bzw. wieder auf ''True'' setzen?
++++


=== Aufgabe A6 – Pulsgeschwindigkeit (Advanced) ===
Gehe von Aufgabe A5 aus. Mit den beiden Tasten soll nun die Pulsgeschwindigkeit (in einer vorgegebenen Range) eingestellt werden können.
++++Tipps:|
== Pulsgeschwindigkeit verstellen ==
  * Definiere erst Variablen: 
    * für die Pausenzeit (zum Beispiel 100)
    * für die Änderung der Pausenzeit (10)
    * für die maximale Pausenzeit (1000)
    * für die minimale Pausenzeit (20)
  * Wenn die Taste A gedrückt ist UND die aktuele Pausenzeit kleiner als die maximale Pausenzeit ist, dann soll die Pausenzeit um die Änderung der Pausenzeit erhöht werden. 
  * Für Taste B passt du die Operatoren und Variablen entsprechend an. 
++++

=== Aufgabe A7 – Pixelwanderung (Advanced) ===

Mit ''set\_pixel()'' und ''get\_pixel()'' kannst du einzelne Pixel direkt ansteuern ([[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 ...

=== Lösungen ===

<nodisp 1>
++++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]

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]

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

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

counter = 9
while counter > 0:
    display.show(counter)
    sleep(1000)
    counter = counter - 1
display.show(Image.BUTTERFLY)
</code>
=== A4 ===

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

=== A5 und A6 ===

<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:
    # change counter for next image
    if up: # going up
        counter = counter + 1
        if counter == 9: 
            up = False  # go down   
    else: # going down
        counter = counter - 1
        if counter == 0:
            up = True  # go up
    
    display.show(create_img(counter))
    sleep(delay)

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

=== A7 ===
== Variante A ==
<code python>
from microbit import *

while True:
    for y in range(5):
        for x in range(5):
            display.set_pixel(x,y,9)
            sleep(100)
            display.clear()
</code>

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

counter = 0
while True:
    row = counter % 5 # get row number
    column = counter // 5 # get column number
    display.set_pixel(row,column,9)
    sleep(100)
    display.clear()

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


==== Aufgaben B (Tasten) ====
Studiere erst den Abschnitt [[..:microbit_programmieren_grundlagen#tasten|Tasten]] im Microbit-Wiki. 
=== Aufgabe B1 – Bild anzeigen und löschen ===

Drückst du die linke Taste, wird ein Herz (oder eine Ente) angezeigt. Drückst du die rechte Taste, so erlöscht das Bild.

=== Aufgabe B2 – Würfeln ===

<WRAP group>
<WRAP column half>
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:programmieren_ii#zufallszahlen|1M Dossier zu Zufallszahlen]]).

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

</WRAP>
<WRAP column half>
**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 |}}

</WRAP>
</WRAP>



=== 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()` oder `was_pressed()` oder `get_presses()` zu verwenden? Warum?

++++ Tipp:|
Mit den Tasten A und B erhöhst oder verringerst du eine Zählvariable, z.B. ''i''. Mit dieser Variable wählst du das das richtige Bild aus der Liste.
++++
=== Aufgabe B4 – Drei Bilder ===
  * Solange Taste A gedrückt ist, soll das Display einen Diamanten zeigen.
  * Solange Taste B gedrückt ist, soll das Display einen Regenschirm zeigen.
  * Solange das Logo berührt ist, soll das Display ein T-Shirt zeigen.
  * Solange keine der drei Tasten gedrückt ist, soll das Display dunkel bleiben.

=== Aufgabe B5 – Linie verschieben ===
<WRAP group>
<WRAP column twothirds>
Das Display soll eine vertikale Linie zeigen. 
  * Mit Taste A kannst du die Linie um eine Spalte nach links schieben, mit Taste B nach rechts.
  * Wenn die Linie bereits ganz links ist und nach links verschoben wird, soll sie am rechten Rand wieder auftauchen (entsprechendes gilt für den umgekehrten Fall). 

++++ Tipp:|
Erstelle eine Liste mit fünf Bildern (jedes Bild zeigt eine andere Linie).
++++

</WRAP>
<WRAP column third>
{{.:aufgaben_hof:pasted:20251106-135050.png}}
</WRAP>
</WRAP>


=== Aufgabe B6 – Wer würfelt höher? (Advanced) ===

Zwei Spielerinnen würfeln abwechslungsweise (eine mit linkem, eine mit rechtem Knopf). Es wird immer die jeweils gewürfelte Zahl angezeigt (als Würfelbild wie in Aufgabe B2 oder als Zahl). 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.

=== Aufgabe B7 – Regentropfen (Advanced) ===
<WRAP group>
<WRAP column twothirds>
Schreibe ein Programm, dass zwei unterscheidliche Animationen zeigt. Mit Taste A kannst du zwischen beiden Animationen wechseln.
  * Animation 1 zeigt fallende Regentropfen: In einer zufällig gewählten Spalte fallen die Regentropfen von oben nach unten. 
  * Animation 2 zeigt aufprallende Regentropfen: Ein zugällig gewähltes Pixel leuchtet erst hell und dann immer dunkler.
</WRAP>
<WRAP column third>
{{:gf_informatik:microbit_und_roboter_programmieren:microbit_raindrops.mp4?200| }}
</WRAP>
</WRAP>
=== Lösungen ===

<nodisp 1>
++++Lösungen Aufgaben B|

=== Aufgabe B1 ===
<code python>
from microbit import *

while True:
    if button_a.get_presses():
        display.show(Image.HEART)
    if button_b.get_presses():
        display.clear()
</code>

=== Aufgabe B2 ===

<code python>
from microbit import *
import random

dice_1 = Image("00000:00000:00900:00000:00000")
dice_2 = Image("00000:09000:00000:00090:00000")
dice_3 = Image("00000:00090:00900:09000:00000")
dice_4 = Image("00000:09090:00000:09090:00000")
dice_5 = Image("00000:09090:00900:09090:00000")
dice_6 = Image("00000:09990:00000:09990:00000")

dice_all = [dice_1,dice_2,dice_3,dice_4,dice_5,dice_6]

while True:
    if button_a.get_presses() or button_b.get_presses():
        dice = random.choice(dice_all)
        display.show(dice)
</code>

=== Aufgabe B3 ===
<code python>
from microbit import *
 
images = [Image.SAD, Image.MEH, Image.YES, Image.NO, Image.COW]
n = len(images) # just a convenience: can use n instead of len(images) from now on

i = 0 # image position

while True:
    display.show(images[i])
    if button_b.get_presses() and i < n-1: # increase position (if not yet at end)
        i += 1
    if button_a.get_presses() and i > 0: # decrease position (if not yet at beginning)
        i -= 1
</code>


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

while True:
    if button_a.is_pressed():
        display.show(Image.DIAMOND)
    elif button_b.is_pressed():
        display.show(Image.UMBRELLA)
    elif pin_logo.is_touched():
        display.show(Image.TSHIRT)
    else:
        display.clear()
</code>

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

s1 = '90000:90000:90000:90000:90000'
s2 = '09000:09000:09000:09000:09000'
s3 = '00900:00900:00900:00900:00900'
s4 = '00090:00090:00090:00090:00090'
s5 = '00009:00009:00009:00009:00009'

lines = (Image(s1), Image(s2), Image(s3), Image(s4), Image(s5))
count = 2
while True:
    if button_a.was_pressed():
        count = (count - 1) % 5
    if button_b.was_pressed():
        count = (count + 1) % 5
    display.show(lines[count])
</code>

=== Aufgabe B6 ===
<code python>
from microbit import *
import random
 
dice_1 = Image("00000:00000:00900:00000:00000")
dice_2 = Image("00000:09000:00000:00090:00000")
dice_3 = Image("00000:00090:00900:09000:00000")
dice_4 = Image("00000:09090:00000:09090:00000")
dice_5 = Image("00000:09090:00900:09090:00000")
dice_6 = Image("00000:09990:00000:09990:00000")
 
dice_all = [dice_1,dice_2,dice_3,dice_4,dice_5,dice_6]

sum_a = 0
sum_b = 0
favorite_a = Image.DUCK
favorite_b = Image.GIRAFFE

while True:
    if button_a.was_pressed():
        number = random.randint(1,6)
        sum_a = sum_a + number
        display.show(dice_all[number-1])
    if button_b.was_pressed():
        number = random.randint(1,6)
        sum_b = sum_b + number
        display.show(dice_all[number-1])
    if sum_a >= 42:
        display.show(favorite_a)
        sleep(2000)
        sum_a = 0
        sum_b = 0
    if sum_b >= 42:
        display.show(favorite_b)
        sleep(2000)
        sum_a = 0
        sum_b = 0
</code>

=== Aufgabe B7 ===
<code python>
from microbit import *
import random

mode = True
col = 2
row = 0

while True:
    display.clear()
    if button_a.was_pressed():
        mode = not mode
    if mode:
        row = random.randint(0,4)
        col = random.randint(0,4)
        for bright in range(9,0,-1):
            display.set_pixel(row, col, bright)
            sleep(30)
    else:
        display.set_pixel(col, row, 9)
        sleep(50)
        if row < 4:
            row = (row + 1)
        else:
            row = 0
            col = random.randint(0,4)
</code>
++++
</nodisp>


==== Aufgaben C (Beschleunigungssensor) ====
Studiere zuerst den Abschnitt [[..:microbit_programmieren_grundlagen#beschleunigungssensor|Beschleunigungssensor]] im Microibt-Wiki. 
=== Aufgabe C1 – Umrechnen ===

Rechenaufgabe (ohne micro:bit). Stelle dir vor, die vom micro:bit gemessene Gesamtbeschleunigung sei $2642$.

   1. Wie vielen $g$'s entspricht dies?
   1. Wandle um in $\text{m}/\text{s}^2$.

=== Aufgabe C2 – Gesamtbeschleunigung berechnen ===

Rechenaufgabe (ohne micro:bit). Unten sind die gemessenen Werte für die Beschleunigungen in die drei Koordinatenrichtungen angegeben. Berechne jeweils die **Gesamtbeschleunigung**:

   1. $(1728, 2020, 2040)$
   1. $(-508, -60, 892)$


=== Aufgabe C3 – xyz-Beschleunigung beobachten ===

Zeige in der Konsole ("Show serial") die Beschleunigungen der drei Koordinatenrichtungen an. Pausiere den micro:bit nach jeder Messung z.B. für eine halbe Sekunde, damit du nicht mit Werten überflutest wirst.

   1. Laufe nun mit dem micro:bit und dem Computer durch das Zimmer und zwar so, dass die $x-$ und die $y-$Beschleunigung möglichst klein sind.
   1. Wie musst du den micro:bit halten und wie musst du dich bewegen?

=== Aufgabe C4 – Gesamtbeschleunigung in $\text{m}/\text{s}^2$ ===

   1. Schreibe ein Programm, welches die **Gesamtbeschleunigung** misst und den Wert in der Konsole ausgibt. Füge nach jeder Messung wieder eine Pause ein.
   1. Hältst du den micro:bit still, sollten der bekannte Wert $9.81$ (oder zumindest Wert in der Nähe davon) angezeigt werden, unabhängig davon, in welche Richtung der micro:bit zeigt.
   1. Bewege den micro:bit nun so, dass du eine möglichst grosse Beschleunigung misst. Beschädige ihn aber nicht!

=== Aufgabe C5 – Gesamtbeschleunigung in drei Einheiten ===

   1. Erweitere Aufgabe C4: Mit den Tasten sollst du nun zwischen drei Modi umstellen können:
      1. Anzeige in mg (z.B. $1018$)
      1. Anzeige in $g$'s (z.B. $1.02$)
      1. Anzeige in $\text{m}/\text{s}^2$ (z.B. $9.98$)




=== Aufgabe C6 – Slow Motion ===
Dein micro:bit soll ein Angry-Face zeigen, sobald der Absolutwert der x- oder der y- Beschleunigung über einem Grenzwert von 100 mg liegt. Solange beide Werte (x und y) unter dem Grenzwert liegen, soll das Display dunkel bleiben.
  - Challenge 1: Lade das Programm auf deinen micro:bit und bewege dich zu einem bestmmten Punkt im Zimmer und wieder zurück, ohne dass das Display auch nur einmal aufleuchtet.
  - Challenge 2: Schaffst du das auch mit einem Grenzwert < 100?

++++ Tipp:|
Die Funktion ''abs()'' gibt den Absolutwert eines Werts zurück.
++++
=== Aufgabe C7 – Je schneller desto heller (Advanced) ===

Je fester der micro:bit beschleunigt wird, desto heller soll die LED-Matrix leuchten. 

Tipp 1: Verwende evtl. deine Funktion aus A5, mit der du ein Bild von gewünschter Helligkeit erstellen kannst.
 
Tipp 2: Verwende die Funktion ''int()'', um aus einer Kommazahl eine Ganzzahl zu machen.

=== Lösungen ===
 
<nodisp 1>
++++Lösungen Aufgaben C|
=== C1 ===

   1. $2.642g$
   1. $25.9\,\text{m}/\text{s}^2$


=== C2 ===

   1. $3351$
   1. $1028$


Bemerkungen:

   * Die Angabe von Nachkommastellen macht hier nicht wirklich Sinn, da diese die Genauigkeit des micro:bit überschreiten.
   * Achtung bei der zweiten Aufgabe: Alle negativen Vorzeichen verschwinden, da sie 'weg quadriert' werden.

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

while True:
    a = accelerometer.get_values()
    print(a)
    sleep(500)
</code>

=== C4 ===
<code python>
from microbit import *
import math
 
while True:
    sleep(500)
    ax, ay, az = accelerometer.get_values()
    a = math.sqrt(ax*ax + ay*ay + az*az)
    a_ms = a/1000*9.81
    print(a_ms)
</code>

=== C5 ===
<code python>
from microbit import *
import math

i = 0

while True:
    ax,ay,az = accelerometer.get_values()
    a = math.sqrt(ax*ax + ay*ay + az*az)
    a_g = a / 1000
    a_si = a_g * 9.81
    a_list = [round(a),round(a_g,2),round(a_si,2)]

    if button_b.get_presses() and i < 2:
        i = i + 1
    if button_a.get_presses() and i > 0:
        i = i - 1

    print(a_list[i])
        
    sleep(1000)
</code>

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

trigger = 100

while True:
    sleep(200)
    ax, ay, az = accelerometer.get_values()
    print(accelerometer.get_values())
    if abs(ax) > trigger or abs(ay) > trigger:
        display.show(Image.ANGRY)
    else:
        display.clear()
</code>

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

def all_pixels(brightness):
    for x in range(5):
        for y in range(5):
            display.set_pixel(x,y,brightness)

while True: 
    x,y,z = accelerometer.get_values()
    total = math.sqrt(x*x + y*y + z*z)
    max = 4000
    fraction = total / max
    brightness = int(fraction * 9)
    all_pixels(brightness)
    sleep(200)
</code>

++++
</nodisp>

==== Aufgaben D (Gesten) ====

Studiere zuerst den kurzen [[gf_informatik:microbit_programmieren_grundlagen#gesten_erkennen|Theorieteil zum Erkennen von Gesten.]]

=== Aufgabe D1 – Ente oder Haus ===
Schreibe ein Programm, das eine Ente anzeigt, wenn du den Microbit schüttelst und ein Haus, wenn du ihn nach oben drehst. 

=== Aufgabe D2 – Magic-8===


<WRAP group>
<WRAP column twothirds>
Probiere den Code für den [[https://microbit-micropython.readthedocs.io/en/latest/tutorials/gestures.html#magic-8|Magic8Ball]] 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!
</WRAP>
<WRAP column third>
{{.:aufgaben_hof:pasted:20251202-071548.png?150}}
</WRAP>
</WRAP>
=== Aufgabe D3 – Schüttelwürfel ===
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 das Modul ''random''.

=== Aufgabe D4 – Schere-Stein-Papier ===

Programmiere **Schere-Stein-Papier**. Die Idee ist, dass du gegen eine Kolleg:in spielen kannst. Beide schütteln jeweils ihren Microbit und dann wird per Zufall eines der drei Symbole ausgewählt und angezeigt. Spiele Best of 5 (also wer zuerst drei Punkte hat).

Weitere Ideen (Advanced):
   * Erweitere das Spiel zur 'The Big Bang Theory'-Variante **Rock, Paper, Scissors, Lizard, Spock**:
     * https://bigbangtheory.fandom.com/wiki/Rock,_Paper,_Scissors,_Lizard,_Spock {{ :gf_informatik:rockpaperscissorbbtheory.jpeg?100 |}}
   * Füge am Anfang ein **Menu** ein, mit dem man z.B. folgendes festlegen kann:
     * die Anzahl Runden
     * den Spielmodus (falls du bereits 'Rock, Paper, Scissors, Lizard, Spock' implementiert hast)
     * jede Spieler:in kann zu beginn aus einer Reihe von Bildern ihr Bild auswählen. Am Schluss wird das Bild der Sieger:in angezeigt.

=== Aufgabe D5 – Eigene Geste-Erkennung (Advanced) ===

Programmiere deine eigene Gesten-Erkennung nur mit dem Accelerometer-Sensor:
  * face up / down
  * up / down / left / right
  * shake
  * freefall

=== Lösungen ===
 
<nodisp 1>
++++Lösungen Aufgaben D|

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

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

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

while True:
    if accelerometer.is_gesture('shake'):
        display.show(random.randint(1,6))
        sleep(500)
</code>

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

rps = [Image.DIAMOND, Image.SQUARE, Image.SCISSORS]

while True:
    if accelerometer.is_gesture('shake'):
        display.show(random.choice(rps))
        sleep(500)
</code>
++++
</nodisp>


==== Aufgaben E (Audio) ====
Studiere zuerst den Abschnitt [[..:microbit_programmieren_grundlagen#sounds|Sounds]] im Microibt-Wiki. 
=== Aufgabe E1 ===
Schreibe eine Programm, das auf Knopfdruck einen Ton mit `music.pitch` abspielt. Welche Frequenz musst du wählen, damit beim Button B eine Oktave zum Ton bei Button A ertönt?

=== Aufgabe E2 ===
Schreibe eine Programm, das eine Melodie abspielt.

  - Verwende eingebaute Sounds mit `audio.play()`.
  - Codiere deine eigene Melodie mit `music.play()`.

=== Aufgabe E3 ===
Schreibe ein Programm, das die Umgebungslautstärke auf dem Display angezeigt (`microphone.sound_level()` - [[https://microbit-micropython.readthedocs.io/en/v2-docs/microphone.html|Dokumentation]]). Je lauter, desto mehr und hellere Punkte sollen leuchten. Wie reagiert der Microbit auf das Programm aus E1 / E2, das auf einem anderen Gerät abgespielt wird?



=== Zusatzaufgabe E4: Mini-Keyboard ===
Schreibe ein Programm, um Musik abzuspielen. Verwende das `pin_logo`, `pin1` und `pin2` als berührungsempfindlicher Sensor (`pin1.set_touch_mode(pin1.CAPACITIVE)`). Wieviele Kombinationen der drei Pins gibt es? Das sollte für eine [[wpde>Diatonik|diatonische Tonleiter]] reichen...




==== Aufgaben F (BLE) ====

   * Arbeite für diese Aufgaben in einer **2er-Gruppe**.
   * Studiere zuerst die **Theorie** zu den [[gf_informatik:microbit_programmieren_grundlagen#grundlagen|Grundlagen.]]

=== Aufgabe F1 – Secret Message! ===

Sendet euch //geheime// Nachrichten quer durch den Raum. Stellt sicher, dass ihr auf einem eigenen Kanal kommuniziert.

=== Aufgabe F2 – Happy or not? ===
  * Schreibe ein Programm, mit dem du deiner Kolleg:in deinen **Gemütszustand** per Funk mitteilen kannst. Je nachdem, welche Taste (inkl. Touch-Logo) du drückst, wird bei ihr ein anderes Smiley (Happy,Meh,Sad) angezeigt.
  * Gleichzeitig soll dein micro:bit auch den Gemütszustand deiner Kolleg:in empfangen können.
  * Achtung: Das **Versenden von Bildern** ist etwas umständlich. Deshalb ist es einfacher, z.B. Zahlen zu verschicken: 1 für Happy, 2 für Meh, 3 für Sad. Möchtest du aber wirklich ein Bild versenden, kannst du [[gf_informatik:microbit_programmieren_grundlagen#versenden_von_bildern|hier]] nachlesen, wie es geht.
  * Das Programm kann auch benutzt werden, um auf Fragen zu antworten: yes (happy), maybe (meh), no (sad). **Interviewt** euch gegenseitig, wobei ihr euch nur über den micro:bit Antworten geben dürft.






=== Aufgabe F3 – Maximale Distanz ===

Studiere die folgende Theorie zu [[gf_informatik:microbit_programmieren_grundlagen#signalstaerke_distanzmessungen|Signalstärke und Distanzmessungen.]]

Was ist etwa die **maximale Distanz in Sichtweite**, über die zwei micro:bits miteinander kommunizieren können? Mache ein Experiment.

Wichtig: Die micro:bits müssen sich 'sehen' können.

++++Tipp:|
Schreibe ein Programm, dass //erstens// fortlaufend irgendeine Nachricht sendet und //zweitens// fortlaufend Nachrichten empfängt und die Signalstärke der empfangenen Nachricht an die Konsole sendet (mit print, am PC "Show Serial" klicken). 
++++

=== Aufgabe F4 – micro:bits in love ===
Die beiden micro:bits sollen beide ein HAPPY, MEH oder SAD-Smiley anzeigen - je nachdem wie weit sie auseinander sind. Da sie verliebt ineinander sind, sollen sie HAPPY sein, wenn sie möglichst nahe beieinander sind. 

Beobachte zuerst die Signal-Stärke (an die Konsole senden) und lege dann passende Grenzwerte fest. 



=== Aufgabe F5 – Buchstaben senden ===
Schreibe ein Programm, mit dem ihr Nachrichten **Buchstabe für Buchatbe** senden und empfangen könnt.
  * Mit den beiden Knöpfen soll das Alphabet durchgegangen werden können. 
  * Mit dem Touch-Logo soll der Buchstabe versendet werden können.
  * Sobald ein Buchstabe empfangen wurde, soll er drei mal hintereinander aufblinken (jeweils ca. 300 ms leuchten und ca. 300 ms dunkel). Dann soll wieder der gerade ausgewählte Buchstaben angezeigt werden.

=== Aufgabe F6 – Abstimmen ===
  - Programmiere deinen Microbit so, dass du mit Mitschüler:innen Abstimmungen durchführen kannst:
    - Wenn die A-Taste gedrückt wurde, sendet dein Micorbit die Nachricht "YES" und zeigt auf dem Display das Bild ''Image.YES''.
    - Wenn die B-Taste gedrückt wurde, sendet dein Micorbit die Nachricht "NO" und zeigt auf dem Display das Bild ''Image.NO''.
    - Wenn das Touch-Logo (pin_logo) berührt wird, zeigt das Display, **wie viele YES- und wie viele NO-Nachrichten empfangen wurden.** Der Text, der durch das Display scrollt, soll beispielsweise so aussehen: "Y: 3. N: 2". Nach dieser Anzeige soll die Zähler wieder auf 0 gesetzt werden.
  - Stimmt ab in Gruppen von drei oder mehr Personen
    * A stellt eine Frage, die anderen stimmen mit den Microbits ab.
    * A schaut auf ihrem Microbit, wie abgestimmt wurde.
    * Simmt beispielsweise darüber ab, wohin ihr Mittagessen gehen sollt oder ob das Fach Informatik besser ist als Physik.
    * Testet zuerst und überprüft, ob alle den gleichen Kanal / die gleiche Gruppe eingestellt haben.

=== Aufgabe F7 – Abstimmen 2 (Advanced) ===
Dein Programm in obiger Aufgabe hat ein Problem: Jemand könnte bei einer Frage mehrmals drücken und so meherere Stimmen abgeben.
Wie kannst du verhindern, dass jemand mehr als eine Stimme abgeben kann? Indem jeder Microbit mit jeder Ja- und Nein-Stimme seine eigene Nummer mitsendet. In einer Liste kannst du die Nummer erfassen und jeweils überprüfen, ob diese Nummer schon abgestimmt hat oder nicht. Schreibe ein Programm, das du auf mehrere Microbits laden und dann faire Abstimmungen durchführen kannst.


=== Aufgabe F8 – Morsen (Advanced) ===

   * Schreibe ein Programm, welches gleichzeitig Morse-Zeichen senden und empfangen kann.
   * Die Symbole sollen auf der LED-Matrix angezeigt werden.
   * Verwende die Tasten, um eine Nachricht einzugeben: Linke Taste: Lang (Strich) , Rechte Taste: Kurz (Punkt)
   * Morsealphabet: https://www.kidstreff.ch/download/XjUbSs_fPR8/31_Geheimschriften_Morsen.pdf
   * Beispiel: S.O.S: `ooo---ooo`
   * Es gibt verschiedene Möglichkeiten, wie die Nachrichten übermittelt werden können, zum Beispiel:
     * 'Schreibe' zuerst ganze Nachricht und schicke sie erst, wenn sie ganz fertig ist (z.B. mit Touch-Logo).
     * Schicke jedes Symbol einzeln. Dann müssen die alten Nachrichten aber jeweils nach unten geschoben werden.


=== Aufgabe F9 – Schere-Stein-Papier revisited (Advanced) ===

In einer früheren Aufgabe hast du Schere-Stein-Papier bereits einmal programmiert. Programmiere es nun so (um), dass die beiden Spieler:innen beide ihren micro:bit in der Hand halten. Um einen Zug zu machen, wird der micro:bit geschüttelt. Die micro:bit kommunizieren natürlich über BLE miteinander. Das Ergebnis eines Zuges und der aktuellste Spielstand könnte auch über den Lautsprecher ausgegeben werden. Im Dossier kannst du nachlesen, wie man Sounds abspielen kann.

=== Aufgabe F10 – Send-a-Tune (Advanced) ===

   * Schreibe ein Programm, mit dem du deiner Kolleg:in eine Melodie senden kannst. Je nachdem, welche Taste (inkl. Touch-Logo) du drückst, wird bei ihr ein anderer Ton abgespielt.
   * Gleichzeitig soll dein micro:bit auch Töne empfangen können.
   * Erweiterungen:
     * Kannst du auch eine ganze Melodie versenden? Du könntest zum Beispiel die Töne mit Kommas trennen und nach dem Empfang mit [[https://docs.python.org/3/library/stdtypes.html#str.split|string.split()]] in eine Liste aufteilen.
     * Statt eines Tons könntest du auch ein Bild versenden. Achtung: Das **Versenden von Bildern** ist etwas umständlich. Lies [[gf_informatik:microbit_programmieren_grundlagen#versenden_von_bildern|hier]] nach, wie es geht.

=== Lösungen ===



==== Aufgaben G (Maqueen) ====

   * Arbeite für diese Aufgaben in einer **2er-Gruppe**.
   * [[gf_informatik:microbit_programmieren_grundlagen#maqueen|Hier]] ist erklärt, wie der Distanzsensor und die Motorsteuerung funktionieren und wie der Microbit mit diesen Modulen kommuniziert.
   * Studiere auf jeden Fall die **Theorie** zum [[gf_informatik:microbit_programmieren_grundlagen#maqueen_interface|Maqueen Interface]]. Das brauchst du, damit du den Maqueen einfach steuern und seine Sensoren auslesen kannst.


=== Aufgabe G1 – Figur abfahren ===

   1. Studiere die Theorie zur **Driver**-Schnittstelle ([[gf_informatik:microbit_programmieren_grundlagen#motorsteuerung|Motorsteuerung]])
   1. Lasse den Maqueen ein **Quadrat** fahren.
   1. Lasse deinen Maqueen eine der folgenden **Optionen** abfahren:
      1. Für **Geometriefreaks**: anspruchsvolle Geometrische Figur (z.B. Pentagramm - wie berechnet man den Winkel der Spitzen? Nicht auf Wikipedia nachschauen!)
      1. Für **Narzist:innen**: eigener Name / Spitzname / Initialen
      1. Für **Schleimer:innen**: Name / Initialen der Lehrperson (aber kein Spitzname!)
      1. Für **Royalist:innen:** Portrait des Königs

=== Aufgabe G2 – Fahren bis zum Hindernis ===

Verwende die `Chassis`-Schnittstelle. Wenn die A-Taste gedrückt wurde, soll der Roboter losfahren. Wenn er ein Hindernis (weniger als 8 cm) vor sich hat, soll er stopppen.
=== Aufgabe G3 – Staubsaugroboter ===

Programmiere einen Staubsaugroboter: Fahre geradeaus bis zu einem Hindernis. Wende um einen zufälligen Winkel und wiederhole.

=== Aufgabe G4 – Remote Control (Advanced) ===

Aufgabe für 2 Personen:
Schreiben Sie eine Fernsteuerung für den Maqueen. Der eine Microbit sendet Signale (links / rechts / geradeaus), der andere empfängt diese und setzt sie in Steuersignale für den Roboter um.

Mögliche Steuerbelegung:
  * Touch Logo: muss berührt werden, um zu fahren; ohne Buttons fährt er geradeaus.
  * Button A: fährt nach links (wenn Touch Logo gleichzeitig gedrückt)
  * Button B: fährt nach rechts (wenn Touch Logo gleichzeitig gedrückt)

Probiere den Roboter aus - würde er funktionieren?
=== Aufgabe G5 – Distanzmesser (Advanced) ===

Schreibe ein Programm, das das Display heller werden lässt, je näher der Maqueen zu einem Objekt ist. Betrachte zuerst den Beispiel-Code in der  Theorie zum [[gf_informatik:microbit_programmieren_grundlagen#distanzmesser|Distanzmesser]].
  * Das Programm soll für einen Distanz-Bereich zwischen 0 und 9 Dezimetern (1 Dezimeter = 10cm) funktionieren.
  * Verwende eine bereits bekannte Methode, um die Display-Helligkeit abhängig von einer Variable zu setzen.

=== Aufgabe G6 – Rendez-vous (Advanced) ===

Verwende deine Kenntnisse zur Funk-Steuerung, um folgende Aufgabe zu lösen:

  * der Roboter soll kollisionsfrei herumfahren (wie der Staubsaug-Roboter)
  * der Roboter soll mittels Radio andere Roboter finden und möglichst nahe zu ihnen fahren. Sind die zwei Roboter nah genug, sollen sie anhalten und ihre Bottom-LEDS auf die gleiche Farbe einstellen.

=== Aufgabe G7 – Follow-the-line (Advanced) ===

Verwende den Bodensensor, um einer schwarzen Linie zu folgen. Signalisiere den Zustand der Bodensensoren mit den Front-LEDs.

  * Wie folgst du einer breiten Linie (5cm)?
  * Wie einer schmalen Linie (1cm)?