===== Aufgaben Microbit =====

Für gewisse Aufgaben gibt es zwei Versionen: Basic und Advanced. Hier hast du die Wahl. 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) ====

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

=== 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 1 ==
   * Ä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.

== Advanced 2 ==
   * Mit den beiden Tasten soll nun die Pulsgeschwindigkeit (in einer vorgegebenen Range) eingestellt werden können.

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

=== Lösungen ===

<nodisp 1>
++++Tipps zu den Aufgaben|
=== A2 ===

Erstelle eine Liste mit Bildern: `my_images = [...]`.
Für das Anzeigen 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.

=== A3 ===

== 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 1 – 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?

\\
== Advanced 1 – 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>

\\
== Advanced 1 – 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>

\\
== Advanced 2 – 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. 

++++
</nodisp>


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

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>

=== 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:
    # 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>

=== A4 ===
== 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:
    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>


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

=== Aufgabe B1 ===

Drückt man die linke Taste, wird ein Herz (oder eine Ente) 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()` oder `was_pressed()` oder `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.

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

++++
</nodisp>


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

=== Aufgabe C1 ===

Rechenaufgabe (ohne micro:bit). Stelle dir vor, ein vom micro:bit gemessener Beschleunigungswert sei $2642$.

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

=== Aufgabe C2 ===

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

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

   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!
   1. Erweiterung: 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 C5 (Advanced) ===

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

Tipp 1: Verwende evtl. deine Funktion aus A3 (Advanced 1), 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.

<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

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>

=== C5 ===
<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 ===
Schreibe ein Programm, das eine Ente anzeigt, wenn du den Microbit schüttelst und ein Haus, wenn du ihn nach oben drehst. 

=== Aufgabe D2 ===
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!

=== Aufgabe D3 ===
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 D4 (Advanced) ===

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:
   * 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 ===

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


==== Aufgaben E (Audio) ====

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

<nodisp 1>
++++Lösung|
<code python>
from microbit import *

while True:
    # Sound level from 0..250
    level = microphone.sound_level()
    # How many leds do we light up?
    leds = int(25 * level / 250)
    # How bright ist the last led?
    brightness = level % 10

    for x in range(5):
        for y in range(5):
            value = x * 5 + y
            if value < leds:
                display.set_pixel(x,y,9)
            elif value == leds:
                display.set_pixel(x,y,brightness)
            else:
                display.set_pixel(x,y,0)

    sleep(10)
</code>
++++
++++Als Equalizer|
<code python>
from microbit import *


while True:
    # Sound level from 0..250
    level = microphone.sound_level()
    # How many leds do we light up?
    leds = int(5 * level / 250)
    # How bright ist the last led?
    brightness = level % 10
 
    for x in range(5):
        for y in range(5):
            if x < 4:
                display.set_pixel(x, y, display.get_pixel(x+1,y))
            elif 4-y < leds:
                display.set_pixel(x, y, 9)
            elif 4-y == leds:
                display.set_pixel(x, y, brightness)
            else:
                display.set_pixel(x, y, 0)
 
    sleep(200)
</code>
++++

</nodisp>

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

<nodisp 1>
++++Lösung|
<code python>
from microbit import *
import music

for pin in [pin0, pin1, pin2, pin_logo]:
    pin.set_touch_mode(pin.CAPACITIVE)
    
# We have three touch pins, giving us
# 8 states. The all-zero state is silence.
# Let's choose a diatonic scale at intervals
# Do: 0/12
# Re: 2/12
# Mi: 4/12
# Fa: 5/12
# So: 7/12
# La: 9/12
# Ti: 11/12
exponents = [-1,0,2,4,5,7,9,11]
base = 440
while True:
    index = 0
    if pin_logo.is_touched():
        index += 1
    if pin1.is_touched():
        index += 2
    if pin2.is_touched():
        index += 4

    # Chromatic stepping using buttons
    if button_a.was_pressed():
        base = (int) (base * 2**(-1/12))
    if button_b.was_pressed():
        base = (int) (base * 2**(1/12))

    if index == 0:
        music.stop()
    else:
        exponent = exponents[index] / 12
        freq = (int) (base * 2**exponent)    
        print(base, exponent, freq)
        music.pitch(freq, duration=-1, wait=False)

    sleep(10)
</code>
++++
</nodisp>


==== 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 F2a: 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 F2b: Send-a-Tune ===

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


=== Aufgabe F3: Morsen ===

   * 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 F4: micro:bits in love ===

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

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.

=== Aufgabe F5: 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 F6: Abstimmen 2 (Zusatzaufgabe, schwierig) ===
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 F7: Maximale Distanz? (Zusatzaufgabe: einfach) ===

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.

=== Aufgabe F8: Nachricht versenden (Zusatzaufgabe: eher einfach) ===

Ähnlich wie die Morse-Aufgabe, nur soll jetzt eine normale Nachricht bestehend aus Buchstaben versendet werden können. Mit den beiden Knöpfen soll das Alphabet durchgegangen werden können. Mit dem Touch-Logo soll der Buchstabe versendet werden können.

=== Aufgabe F9: Schere-Stein-Papier revisited (Zusatzaufgabe: mittel-schwierig) ===

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.

<nodisp 1>
++++Lösungen Aufgaben F|
=== F1 ===
<code python>
from microbit import *
import radio
 
radio.on()
 
while True:
    message_in = radio.receive()
    if message_in:
        display.scroll(message_in)
 
    if button_a.is_pressed():
        radio.send('Geheime Nachricht!')
</code>

=== F2 ===
<code python>
from microbit import *
import radio
 
radio.on()
 
while True:
    message_in = radio.receive()
    if message_in:
        if message_in == '1':
            display.show(Image.HAPPY)
        elif message_in == '2':
            display.show(Image.MEH)
        elif message_in == '3':
            display.show(Image.SAD)
 
    if button_a.is_pressed():
        radio.send('1')
    if pin_logo.is_touched():
        radio.send('2')
    if button_b.is_pressed():
        radio.send('3')
</code>

=== F3 ===
Einfache aber nicht sehr elegante Lösung:
<code python>
from microbit import *
import radio
 
radio.on()

morse = ['','','','','']
matrix = ['00000','00000','00000','00000','00000']

while True:
    message_in = radio.receive()

    # trage neue Symbole in morse liste ein, entferne letztes Element (damit Laenge 5 bleibt)
    if message_in:
        morse.insert(0,message_in)
        morse.pop()

    # erstelle Matrix fuer Anzeige
    for i in range(len(morse)):
        if morse[i] == 'long':
            matrix[i] = '99999'
        elif morse[i] == 'short':
            matrix[i] = '00900'
        else:
            matrix[i] = '00000'

    # wandle Matrix in string um, damit angezeigt werden kann
    s = matrix[0] + ':' + matrix[1] + ':' + matrix[2] + ':' + matrix[3] + ':' + matrix[4] 
    display.show(Image(s))

    # Buttons
    if button_a.get_presses():
        radio.send('long')
    if button_b.get_presses():
        radio.send('short')
</code>
Elegantere Lösung:
<code python>
from microbit import *
import radio
 
radio.on()

morse = ['','','','','']
smth_changed = False

def show(m):
    display.clear()
    for y in range(len(morse)):
        if morse[y] == 'long':
            for x in range(5):
                display.set_pixel(x,y,9)
        elif morse[y] == 'short':
                display.set_pixel(2,y,9)

while True:
    message_in = radio.receive()

    # trage neue Symbole in morse liste ein, entferne letztes Element (damit Laenge 5 bleibt)
    if message_in:
        morse.insert(0,message_in)
        morse.pop()
        smth_changed = True

    # update led-matrix nur falls etwas geaendert hat
    if smth_changed:
        show(morse)
        smth_changed = False

    # Buttons
    if button_a.get_presses():
        radio.send('long')
    if button_b.get_presses():
        radio.send('short')
</code>

=== F4 ===
<code python>
from microbit import *
import radio
 
radio.on()
radio.config(group = 43)

while True:
    # send
    radio.send('hello')

    # receive
    message_full = radio.receive_full()
    if message_full:
        text = message_full[0]
        signal_strength = abs(message_full[1])
        print(signal_strength)
        if signal_strength < 35:
            display.show(Image.HAPPY)
        elif signal_strength < 55:
            display.show(Image.MEH)
        else:
            display.show(Image.SAD)

    sleep(50)
</code>
++++
</nodisp>

==== 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 G0: Distanzmesser (schwieriger als gedacht) ===

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

Probiere den Roboter aus - würde er funktionieren?

=== Aufgabe G4 (Advanced): Rendez-vous ===

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 G5 (Advanced): Follow-the-line ===

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

=== Aufgabe G6 (Medium): Remote Control ===

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)

<nodisp 1>
++++Lösungen|
=== G1 ===
<code python>
from microbit import *
from maqueen import *

robot = Maqueen()
driver = robot.driver

while True:
    if button_a.was_pressed():
        for i in range(4):
            driver.drive(10)
            driver.right(90)
</code>

=== G2 ===
<code python>
from microbit import *
from maqueen import *

robot = Maqueen()
chassis = robot.chassis

while True:
    if button_a.was_pressed():
        chassis.forward()
        while robot.front_sensor.distance() > 10:
            sleep(50)
        chassis.stop()
</code>
++++
</nodisp>
<nodisp 1>
++++Lösungen|

=== G3 ===
<code python>
from microbit import *
from maqueen import *
import random

robot = Maqueen()

def hoover():
    while True:
        # Straight ahead!
        robot.chassis.forward()
        distance = robot.front_sensor.distance(attempts=3)
        print(distance)
        while distance > 15 or distance < 0:
            sleep(50)
            distance = robot.front_sensor.distance(attempts=3)
 
        # Obstacle - random turning!
        robot.chassis.stop()

        # Back off if we're too close.
        if distance < 15:
            robot.driver.drive(-10)
        
        degrees = random.randint(40,120)
        direction = random.randint(0,1)
        if direction == 1:
            robot.driver.left(degrees)
        else:
            robot.driver.right(degrees)
    

while True:
    if button_a.was_pressed():
        hoover()
</code>

=== G6 ===
[[https://kantonsschuleromanshorn.sharepoint.com/:u:/s/FSInformatik/ES3h9tA-ADdHneC8v6iJ4lABgraB3RbvGbc4QB3CzF6gxQ?e=M4iD24|remote_control.hex]]

++++
</nodisp>